memory.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/types.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winternl.h"
#include "winerror.h"
#include "ddk/wdm.h"
#include "kernelbase.h"
#include "wine/exception.h"
#include "wine/debug.h"

Include dependency graph for memory.c:

Go to the source code of this file.

Classes
struct	rtl_heap_entry
struct	kernelbase_global_data
struct	mem_entry

Macros
#define	WIN32_NO_STATUS
#define	ROUND_ADDR(addr)   ((void *)((UINT_PTR)(addr) & ~page_mask))
#define	ROUND_SIZE(addr, size)   (((SIZE_T)(size) + ((UINT_PTR)(addr) & page_mask) + page_mask) & ~page_mask)
#define	RTL_HEAP_ENTRY_BUSY   0x0001
#define	RTL_HEAP_ENTRY_REGION   0x0002
#define	RTL_HEAP_ENTRY_BLOCK   0x0010
#define	RTL_HEAP_ENTRY_UNCOMMITTED   0x1000
#define	RTL_HEAP_ENTRY_COMMITTED   0x4000
#define	RTL_HEAP_ENTRY_LFH   0x8000
#define	HEAP_ADD_USER_INFO   0x00000100
#define	MEM_FLAG_USED   1
#define	MEM_FLAG_MOVEABLE   2
#define	MEM_FLAG_DISCARDABLE   4
#define	MEM_FLAG_DISCARDED   8
#define	MEM_FLAG_DDESHARE   0x8000
#define	MAX_MEM_HANDLES   0x10000

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (heap)
	WINE_DECLARE_DEBUG_CHANNEL (virtual)
	WINE_DECLARE_DEBUG_CHANNEL (globalmem)
static CROSS_PROCESS_WORK_LIST *	open_cross_process_connection (HANDLE process)
static void	close_cross_process_connection (CROSS_PROCESS_WORK_LIST *list)
static void	send_cross_process_notification (CROSS_PROCESS_WORK_LIST *list, UINT id, const void *addr, SIZE_T size, int nb_args,...)
DWORD WINAPI DECLSPEC_HOTPATCH	DiscardVirtualMemory (void *addr, SIZE_T size)
BOOL WINAPI DECLSPEC_HOTPATCH	FlushViewOfFile (const void *base, SIZE_T size)
BOOL WINAPI DECLSPEC_HOTPATCH	FlushInstructionCache (HANDLE process, LPCVOID addr, SIZE_T size)
SIZE_T WINAPI	GetLargePageMinimum (void)
static void	fill_system_info (SYSTEM_INFO *si, const SYSTEM_BASIC_INFORMATION *basic_info, const SYSTEM_CPU_INFORMATION *cpu_info)
void WINAPI DECLSPEC_HOTPATCH	GetNativeSystemInfo (SYSTEM_INFO *si)
void WINAPI DECLSPEC_HOTPATCH	GetSystemInfo (SYSTEM_INFO *si)
BOOL WINAPI DECLSPEC_HOTPATCH	GetSystemFileCacheSize (SIZE_T *mincache, SIZE_T *maxcache, DWORD *flags)
UINT WINAPI DECLSPEC_HOTPATCH	GetWriteWatch (DWORD flags, void *base, SIZE_T size, void **addresses, ULONG_PTR *count, ULONG *granularity)
LPVOID WINAPI DECLSPEC_HOTPATCH	MapViewOfFile (HANDLE mapping, DWORD access, DWORD offset_high, DWORD offset_low, SIZE_T count)
LPVOID WINAPI DECLSPEC_HOTPATCH	MapViewOfFileEx (HANDLE handle, DWORD access, DWORD offset_high, DWORD offset_low, SIZE_T count, LPVOID addr)
LPVOID WINAPI DECLSPEC_HOTPATCH	MapViewOfFileFromApp (HANDLE handle, ULONG access, ULONG64 offset, SIZE_T size)
LPVOID WINAPI DECLSPEC_HOTPATCH	MapViewOfFile3 (HANDLE handle, HANDLE process, PVOID baseaddr, ULONG64 offset, SIZE_T size, ULONG alloc_type, ULONG protection, MEM_EXTENDED_PARAMETER *params, ULONG params_count)
BOOL WINAPI DECLSPEC_HOTPATCH	ReadProcessMemory (HANDLE process, const void *addr, void *buffer, SIZE_T size, SIZE_T *bytes_read)
UINT WINAPI DECLSPEC_HOTPATCH	ResetWriteWatch (void *base, SIZE_T size)
BOOL WINAPI DECLSPEC_HOTPATCH	SetSystemFileCacheSize (SIZE_T mincache, SIZE_T maxcache, DWORD flags)
BOOL WINAPI DECLSPEC_HOTPATCH	UnmapViewOfFile (const void *addr)
BOOL WINAPI DECLSPEC_HOTPATCH	UnmapViewOfFile2 (HANDLE process, void *addr, ULONG flags)
BOOL WINAPI DECLSPEC_HOTPATCH	UnmapViewOfFileEx (void *addr, ULONG flags)
LPVOID WINAPI DECLSPEC_HOTPATCH	VirtualAlloc (void *addr, SIZE_T size, DWORD type, DWORD protect)
LPVOID WINAPI DECLSPEC_HOTPATCH	VirtualAllocEx (HANDLE process, void *addr, SIZE_T size, DWORD type, DWORD protect)
LPVOID WINAPI DECLSPEC_HOTPATCH	VirtualAlloc2 (HANDLE process, void *addr, SIZE_T size, DWORD type, DWORD protect, MEM_EXTENDED_PARAMETER *parameters, ULONG count)
static BOOL	is_exec_prot (DWORD protect)
LPVOID WINAPI DECLSPEC_HOTPATCH	VirtualAlloc2FromApp (HANDLE process, void *addr, SIZE_T size, DWORD type, DWORD protect, MEM_EXTENDED_PARAMETER *parameters, ULONG count)
LPVOID WINAPI DECLSPEC_HOTPATCH	VirtualAllocFromApp (void *addr, SIZE_T size, DWORD type, DWORD protect)
BOOL WINAPI DECLSPEC_HOTPATCH	PrefetchVirtualMemory (HANDLE process, ULONG_PTR count, WIN32_MEMORY_RANGE_ENTRY *addresses, ULONG flags)
BOOL WINAPI DECLSPEC_HOTPATCH	VirtualFree (void *addr, SIZE_T size, DWORD type)
BOOL WINAPI DECLSPEC_HOTPATCH	VirtualFreeEx (HANDLE process, void *addr, SIZE_T size, DWORD type)
BOOL WINAPI DECLSPEC_HOTPATCH	VirtualLock (void *addr, SIZE_T size)
BOOL WINAPI DECLSPEC_HOTPATCH	VirtualProtect (void *addr, SIZE_T size, DWORD new_prot, DWORD *old_prot)
BOOL WINAPI DECLSPEC_HOTPATCH	VirtualProtectEx (HANDLE process, void *addr, SIZE_T size, DWORD new_prot, DWORD *old_prot)
SIZE_T WINAPI DECLSPEC_HOTPATCH	VirtualQuery (LPCVOID addr, PMEMORY_BASIC_INFORMATION info, SIZE_T len)
SIZE_T WINAPI DECLSPEC_HOTPATCH	VirtualQueryEx (HANDLE process, LPCVOID addr, PMEMORY_BASIC_INFORMATION info, SIZE_T len)
BOOL WINAPI DECLSPEC_HOTPATCH	VirtualUnlock (void *addr, SIZE_T size)
BOOL WINAPI DECLSPEC_HOTPATCH	WriteProcessMemory (HANDLE process, void *addr, const void *buffer, SIZE_T size, SIZE_T *bytes_written)
BOOL WINAPI	IsBadStringPtrA (LPCSTR str, UINT_PTR max)
BOOL WINAPI	IsBadStringPtrW (LPCWSTR str, UINT_PTR max)
SIZE_T WINAPI DECLSPEC_HOTPATCH	HeapCompact (HANDLE heap, DWORD flags)
HANDLE WINAPI DECLSPEC_HOTPATCH	HeapCreate (DWORD flags, SIZE_T init_size, SIZE_T max_size)
BOOL WINAPI DECLSPEC_HOTPATCH	HeapDestroy (HANDLE heap)
BOOL WINAPI DECLSPEC_HOTPATCH	HeapLock (HANDLE heap)
BOOL WINAPI	HeapQueryInformation (HANDLE heap, HEAP_INFORMATION_CLASS info_class, PVOID info, SIZE_T size, PSIZE_T size_out)
BOOL WINAPI	HeapSetInformation (HANDLE heap, HEAP_INFORMATION_CLASS infoclass, PVOID info, SIZE_T size)
BOOL WINAPI	HeapUnlock (HANDLE heap)
BOOL WINAPI DECLSPEC_HOTPATCH	HeapValidate (HANDLE heap, DWORD flags, LPCVOID ptr)
BOOL WINAPI DECLSPEC_HOTPATCH	HeapWalk (HANDLE heap, PROCESS_HEAP_ENTRY *entry)
	C_ASSERT (sizeof(struct mem_entry)==2 *sizeof(void *))
static struct mem_entry *	unsafe_mem_from_HLOCAL (HLOCAL handle)
static HLOCAL	HLOCAL_from_mem (struct mem_entry *mem)
static void *	unsafe_ptr_from_HLOCAL (HLOCAL handle)
void	init_global_data (void)
void *WINAPI	KernelBaseGetGlobalData (void)
HGLOBAL WINAPI DECLSPEC_HOTPATCH	GlobalAlloc (UINT flags, SIZE_T size)
HGLOBAL WINAPI DECLSPEC_HOTPATCH	GlobalFree (HLOCAL handle)
HLOCAL WINAPI DECLSPEC_HOTPATCH	LocalAlloc (UINT flags, SIZE_T size)
HLOCAL WINAPI DECLSPEC_HOTPATCH	LocalFree (HLOCAL handle)
LPVOID WINAPI DECLSPEC_HOTPATCH	LocalLock (HLOCAL handle)
HLOCAL WINAPI DECLSPEC_HOTPATCH	LocalReAlloc (HLOCAL handle, SIZE_T size, UINT flags)
BOOL WINAPI DECLSPEC_HOTPATCH	LocalUnlock (HLOCAL handle)
HANDLE WINAPI DECLSPEC_HOTPATCH	CreateMemoryResourceNotification (MEMORY_RESOURCE_NOTIFICATION_TYPE type)
BOOL WINAPI DECLSPEC_HOTPATCH	QueryMemoryResourceNotification (HANDLE handle, BOOL *state)
BOOL WINAPI DECLSPEC_HOTPATCH	AllocateUserPhysicalPages (HANDLE process, ULONG_PTR *pages, ULONG_PTR *userarray)
BOOL WINAPI DECLSPEC_HOTPATCH	FreeUserPhysicalPages (HANDLE process, ULONG_PTR *pages, ULONG_PTR *userarray)
BOOL WINAPI DECLSPEC_HOTPATCH	GetPhysicallyInstalledSystemMemory (ULONGLONG *memory)
BOOL WINAPI DECLSPEC_HOTPATCH	GlobalMemoryStatusEx (MEMORYSTATUSEX *status)
BOOL WINAPI DECLSPEC_HOTPATCH	MapUserPhysicalPages (void *addr, ULONG_PTR page_count, ULONG_PTR *pages)
BOOL WINAPI DECLSPEC_HOTPATCH	AllocateUserPhysicalPagesNuma (HANDLE process, ULONG_PTR *pages, ULONG_PTR *userarray, DWORD node)
HANDLE WINAPI DECLSPEC_HOTPATCH	CreateFileMappingNumaW (HANDLE file, LPSECURITY_ATTRIBUTES sa, DWORD protect, DWORD size_high, DWORD size_low, LPCWSTR name, DWORD node)
BOOL WINAPI DECLSPEC_HOTPATCH	GetLogicalProcessorInformation (SYSTEM_LOGICAL_PROCESSOR_INFORMATION *buffer, DWORD *len)
BOOL WINAPI DECLSPEC_HOTPATCH	GetLogicalProcessorInformationEx (LOGICAL_PROCESSOR_RELATIONSHIP relationship, SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, DWORD *len)
BOOL WINAPI	GetSystemCpuSetInformation (SYSTEM_CPU_SET_INFORMATION *info, ULONG buffer_length, ULONG *return_length, HANDLE process, ULONG flags)
BOOL WINAPI	SetThreadSelectedCpuSets (HANDLE thread, const ULONG *cpu_set_ids, ULONG count)
BOOL WINAPI	SetProcessDefaultCpuSets (HANDLE process, const ULONG *cpu_set_ids, ULONG count)
BOOL WINAPI DECLSPEC_HOTPATCH	GetNumaHighestNodeNumber (ULONG *node)
BOOL WINAPI DECLSPEC_HOTPATCH	GetNumaNodeProcessorMaskEx (USHORT node, GROUP_AFFINITY *mask)
BOOL WINAPI DECLSPEC_HOTPATCH	GetNumaProximityNodeEx (ULONG proximity_id, USHORT *node)
LPVOID WINAPI DECLSPEC_HOTPATCH	MapViewOfFileExNuma (HANDLE handle, DWORD access, DWORD offset_high, DWORD offset_low, SIZE_T count, LPVOID addr, DWORD node)
LPVOID WINAPI DECLSPEC_HOTPATCH	VirtualAllocExNuma (HANDLE process, void *addr, SIZE_T size, DWORD type, DWORD protect, DWORD node)
BOOL WINAPI DECLSPEC_HOTPATCH	QueryVirtualMemoryInformation (HANDLE process, const void *addr, WIN32_MEMORY_INFORMATION_CLASS info_class, void *info, SIZE_T size, SIZE_T *ret_size)
BOOL WINAPI	InitializeContext2 (void *buffer, DWORD context_flags, CONTEXT **context, DWORD *length, ULONG64 compaction_mask)
BOOL WINAPI	InitializeContext (void *buffer, DWORD context_flags, CONTEXT **context, DWORD *length)
BOOL WINAPI	CopyContext (CONTEXT *dst, DWORD context_flags, CONTEXT *src)
static UINT	get_firmware_table (DWORD provider, SYSTEM_FIRMWARE_TABLE_ACTION action, DWORD id, void *buffer, DWORD size)
UINT WINAPI	EnumSystemFirmwareTables (DWORD provider, void *buffer, DWORD size)
UINT WINAPI	GetSystemFirmwareTable (DWORD provider, DWORD id, void *buffer, DWORD size)

Variables
static const SIZE_T	page_mask = 0xfff
static struct mem_entry *	next_free_mem
static struct kernelbase_global_data	global_data = {0}

Macro Definition Documentation

HEAP_ADD_USER_INFO

#define HEAP_ADD_USER_INFO   0x00000100

Definition at line 874 of file memory.c.

MAX_MEM_HANDLES

#define MAX_MEM_HANDLES   0x10000

Definition at line 905 of file memory.c.

MEM_FLAG_DDESHARE

#define MEM_FLAG_DDESHARE   0x8000

Definition at line 887 of file memory.c.

MEM_FLAG_DISCARDABLE

#define MEM_FLAG_DISCARDABLE   4

Definition at line 885 of file memory.c.

MEM_FLAG_DISCARDED

#define MEM_FLAG_DISCARDED   8

Definition at line 886 of file memory.c.

MEM_FLAG_MOVEABLE

#define MEM_FLAG_MOVEABLE   2

Definition at line 884 of file memory.c.

MEM_FLAG_USED

#define MEM_FLAG_USED   1

Definition at line 883 of file memory.c.

ROUND_ADDR

#define ROUND_ADDR

(

addr

)

((void *)((UINT_PTR)(addr) & ~page_mask))

Definition at line 97 of file memory.c.

ROUND_SIZE

#define ROUND_SIZE	(		addr,
			size
	)		(((SIZE_T)(size) + ((UINT_PTR)(addr) & page_mask) + page_mask) & ~page_mask)

Definition at line 98 of file memory.c.

RTL_HEAP_ENTRY_BLOCK

#define RTL_HEAP_ENTRY_BLOCK   0x0010

Definition at line 817 of file memory.c.

RTL_HEAP_ENTRY_BUSY

#define RTL_HEAP_ENTRY_BUSY   0x0001

Definition at line 815 of file memory.c.

RTL_HEAP_ENTRY_COMMITTED

#define RTL_HEAP_ENTRY_COMMITTED   0x4000

Definition at line 819 of file memory.c.

RTL_HEAP_ENTRY_LFH

#define RTL_HEAP_ENTRY_LFH   0x8000

Definition at line 820 of file memory.c.

RTL_HEAP_ENTRY_REGION

#define RTL_HEAP_ENTRY_REGION   0x0002

Definition at line 816 of file memory.c.

RTL_HEAP_ENTRY_UNCOMMITTED

#define RTL_HEAP_ENTRY_UNCOMMITTED   0x1000

Definition at line 818 of file memory.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 28 of file memory.c.

Function Documentation

AllocateUserPhysicalPages()

BOOL WINAPI DECLSPEC_HOTPATCH AllocateUserPhysicalPages	(	HANDLE	process,
		ULONG_PTR *	pages,
		ULONG_PTR *	userarray
	)

Definition at line 1289 of file memory.c.

{
    FIXME( "stub: %p %p %p\n", process, pages, userarray );
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

Referenced by AllocateUserPhysicalPagesNuma().

AllocateUserPhysicalPagesNuma()

BOOL WINAPI DECLSPEC_HOTPATCH AllocateUserPhysicalPagesNuma	(	HANDLE	process,
		ULONG_PTR *	pages,
		ULONG_PTR *	userarray,
		DWORD	node
	)

Definition at line 1408 of file memory.c.

{
    if (node) FIXME( "Ignoring preferred node %lu\n", node );
    return AllocateUserPhysicalPages( process, pages, userarray );
}

C_ASSERT()

C_ASSERT

(

sizeof(struct mem_entry)

= =2 *sizeof(void *)

)

close_cross_process_connection()

static void close_cross_process_connection ( CROSS_PROCESS_WORK_LIST *  list )

static

Definition at line 60 of file memory.c.

{
    if (list) NtUnmapViewOfSection( GetCurrentProcess(), list );
}

Referenced by FlushInstructionCache(), and WriteProcessMemory().

CopyContext()

BOOL WINAPI CopyContext	(	CONTEXT *	dst,
		DWORD	context_flags,
		CONTEXT *	src
	)

Definition at line 1633 of file memory.c.

{
    return set_ntstatus( RtlCopyContext( dst, context_flags, src ));
}

Referenced by FileCopyCallback(), FileCopyPage(), MoveFileWithProgressW(), PrepareAndDoCopyThread(), and SetupUpdateMemoryInfo().

CreateFileMappingNumaW()

HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileMappingNumaW	(	HANDLE	file,
		LPSECURITY_ATTRIBUTES	sa,
		DWORD	protect,
		DWORD	size_high,
		DWORD	size_low,
		LPCWSTR	name,
		DWORD	node
	)

Definition at line 1419 of file memory.c.

{
    if (node) FIXME( "Ignoring preferred node %lu\n", node );
    return CreateFileMappingW( file, sa, protect, size_high, size_low, name );
}

CreateMemoryResourceNotification()

HANDLE WINAPI DECLSPEC_HOTPATCH CreateMemoryResourceNotification

(

MEMORY_RESOURCE_NOTIFICATION_TYPE

type

)

Definition at line 1238 of file memory.c.

{
    HANDLE ret;
    UNICODE_STRING nameW;
    OBJECT_ATTRIBUTES attr;
 
    switch (type)
    {
    case LowMemoryResourceNotification:
        RtlInitUnicodeString( &nameW, L"\\KernelObjects\\LowMemoryCondition" );
        break;
    case HighMemoryResourceNotification:
        RtlInitUnicodeString( &nameW, L"\\KernelObjects\\HighMemoryCondition" );
        break;
    default:
        SetLastError( ERROR_INVALID_PARAMETER );
        return 0;
    }
 
    InitializeObjectAttributes( &attr, &nameW, 0, 0, NULL );
    if (!set_ntstatus( NtOpenEvent( &ret, EVENT_ALL_ACCESS, &attr ))) return 0;
    return ret;
}

DiscardVirtualMemory()

DWORD WINAPI DECLSPEC_HOTPATCH DiscardVirtualMemory	(	void *	addr,
		SIZE_T	size
	)

Definition at line 103 of file memory.c.

{
    NTSTATUS status;
    LPVOID ret = addr;
 
    status = NtAllocateVirtualMemory( GetCurrentProcess(), &ret, 0, &size, MEM_RESET, PAGE_NOACCESS );
    return RtlNtStatusToDosError( status );
}

EnumSystemFirmwareTables()

UINT WINAPI EnumSystemFirmwareTables	(	DWORD	provider,
		void *	buffer,
		DWORD	size
	)

Definition at line 1817 of file memory.c.

{
    TRACE( "(0x%08lx, %p, %ld)\n", provider, buffer, size );
 
    return get_firmware_table( provider, SystemFirmwareTable_Enumerate, 0, buffer, size );
}

fill_system_info()

static void fill_system_info ( SYSTEM_INFO *  si, const SYSTEM_BASIC_INFORMATION *  basic_info, const SYSTEM_CPU_INFORMATION *  cpu_info  )

static

Definition at line 150 of file memory.c.

{
    si->wProcessorArchitecture      = cpu_info->ProcessorArchitecture;
    si->wReserved                   = 0;
    si->dwPageSize                  = basic_info->PageSize;
    si->lpMinimumApplicationAddress = basic_info->LowestUserAddress;
    si->lpMaximumApplicationAddress = basic_info->HighestUserAddress;
    si->dwActiveProcessorMask       = basic_info->ActiveProcessorsAffinityMask;
    si->dwNumberOfProcessors        = basic_info->NumberOfProcessors;
    si->dwAllocationGranularity     = basic_info->AllocationGranularity;
    si->wProcessorLevel             = cpu_info->ProcessorLevel;
    si->wProcessorRevision          = cpu_info->ProcessorRevision;
 
    switch (cpu_info->ProcessorArchitecture)
    {
    case PROCESSOR_ARCHITECTURE_INTEL:
        switch (cpu_info->ProcessorLevel)
        {
        case 3:  si->dwProcessorType = PROCESSOR_INTEL_386;     break;
        case 4:  si->dwProcessorType = PROCESSOR_INTEL_486;     break;
        case 5:
        case 6:  si->dwProcessorType = PROCESSOR_INTEL_PENTIUM; break;
        default: si->dwProcessorType = PROCESSOR_INTEL_PENTIUM; break;
        }
        break;
    case PROCESSOR_ARCHITECTURE_AMD64:
        si->dwProcessorType = PROCESSOR_AMD_X8664;
        break;
    case PROCESSOR_ARCHITECTURE_ARM:
        switch (cpu_info->ProcessorLevel)
        {
        case 4:  si->dwProcessorType = PROCESSOR_ARM_7TDMI;     break;
        default: si->dwProcessorType = PROCESSOR_ARM920;
        }
        break;
    case PROCESSOR_ARCHITECTURE_ARM64:
        si->dwProcessorType = 0;
        break;
    default:
        FIXME( "Unknown processor architecture %x\n", cpu_info->ProcessorArchitecture );
        si->dwProcessorType = 0;
        break;
    }
}

Referenced by GetNativeSystemInfo(), and GetSystemInfo().

FlushInstructionCache()

BOOL WINAPI DECLSPEC_HOTPATCH FlushInstructionCache	(	HANDLE	process,
		LPCVOID	addr,
		SIZE_T	size
	)

Definition at line 128 of file memory.c.

{
    CROSS_PROCESS_WORK_LIST *list;
 
    if ((list = open_cross_process_connection( process )))
    {
        send_cross_process_notification( list, CrossProcessFlushCache, addr, size, 0 );
        close_cross_process_connection( list );
    }
    return set_ntstatus( NtFlushInstructionCache( process, addr, size ));
}

FlushViewOfFile()

BOOL WINAPI DECLSPEC_HOTPATCH FlushViewOfFile	(	const void *	base,
		SIZE_T	size
	)

Definition at line 116 of file memory.c.

{
    NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 );
 
    if (status == STATUS_NOT_MAPPED_DATA) status = STATUS_SUCCESS;
    return set_ntstatus( status );
}

FreeUserPhysicalPages()

BOOL WINAPI DECLSPEC_HOTPATCH FreeUserPhysicalPages	(	HANDLE	process,
		ULONG_PTR *	pages,
		ULONG_PTR *	userarray
	)

Definition at line 1301 of file memory.c.

{
    FIXME( "stub: %p %p %p\n", process, pages, userarray );
    *pages = 0;
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

get_firmware_table()

static UINT get_firmware_table ( DWORD  provider, SYSTEM_FIRMWARE_TABLE_ACTION  action, DWORD  id, void *  buffer, DWORD  size  )

static

Definition at line 1788 of file memory.c.

{
    SYSTEM_FIRMWARE_TABLE_INFORMATION *info;
    ULONG buffer_size = offsetof( SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer ) + size;
    NTSTATUS status;
 
    if (!(info = RtlAllocateHeap( GetProcessHeap(), 0, buffer_size )))
    {
        SetLastError( ERROR_OUTOFMEMORY );
        return 0;
    }
 
    info->ProviderSignature = provider;
    info->Action = action;
    info->TableID = id;
 
    status = NtQuerySystemInformation( SystemFirmwareTableInformation, info, buffer_size, &buffer_size );
    set_ntstatus(status);
    buffer_size -= offsetof( SYSTEM_FIRMWARE_TABLE_INFORMATION, TableBuffer );
    if (buffer_size <= size) memcpy( buffer, info->TableBuffer, buffer_size );
 
    HeapFree( GetProcessHeap(), 0, info );
    return NT_SUCCESS(status) || status == STATUS_BUFFER_TOO_SMALL ? buffer_size : 0;
}

Referenced by EnumSystemFirmwareTables(), and GetSystemFirmwareTable().

GetLargePageMinimum()

SIZE_T WINAPI GetLargePageMinimum

(

void

)

Definition at line 144 of file memory.c.

{
    return 2 * 1024 * 1024;
}

GetLogicalProcessorInformation()

BOOL WINAPI DECLSPEC_HOTPATCH GetLogicalProcessorInformation	(	SYSTEM_LOGICAL_PROCESSOR_INFORMATION *	buffer,
		DWORD *	len
	)

Definition at line 1431 of file memory.c.

{
    NTSTATUS status;
 
    if (!len)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    status = NtQuerySystemInformation( SystemLogicalProcessorInformation, buffer, *len, len );
    if (status == STATUS_INFO_LENGTH_MISMATCH) status = STATUS_BUFFER_TOO_SMALL;
    return set_ntstatus( status );
}

GetLogicalProcessorInformationEx()

BOOL WINAPI DECLSPEC_HOTPATCH GetLogicalProcessorInformationEx	(	LOGICAL_PROCESSOR_RELATIONSHIP	relationship,
		SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *	buffer,
		DWORD *	len
	)

Definition at line 1450 of file memory.c.

{
    NTSTATUS status;
 
    if (!len)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    status = NtQuerySystemInformationEx( SystemLogicalProcessorInformationEx, &relationship,
                                         sizeof(relationship), buffer, *len, len );
    if (status == STATUS_INFO_LENGTH_MISMATCH) status = STATUS_BUFFER_TOO_SMALL;
    return set_ntstatus( status );
}

GetNativeSystemInfo()

void WINAPI DECLSPEC_HOTPATCH GetNativeSystemInfo

(

SYSTEM_INFO *

si

)

Definition at line 200 of file memory.c.

{
    SYSTEM_BASIC_INFORMATION basic_info;
    SYSTEM_CPU_INFORMATION cpu_info;
 
    if (is_wow64)
    {
        USHORT current_machine, native_machine;
 
        RtlWow64GetProcessMachines( 0, &current_machine, &native_machine );
        if (native_machine != IMAGE_FILE_MACHINE_AMD64)
        {
            GetSystemInfo( si );
            si->wProcessorArchitecture = PROCESSOR_ARCHITECTURE_AMD64;
            return;
        }
    }
 
    if (!set_ntstatus( RtlGetNativeSystemInformation( SystemBasicInformation,
                                                      &basic_info, sizeof(basic_info), NULL )) ||
        !set_ntstatus( RtlGetNativeSystemInformation( SystemCpuInformation,
                                                      &cpu_info, sizeof(cpu_info), NULL )))
        return;
 
    fill_system_info( si, &basic_info, &cpu_info );
}

GetNumaHighestNodeNumber()

BOOL WINAPI DECLSPEC_HOTPATCH GetNumaHighestNodeNumber

(

ULONG *

node

)

Definition at line 1508 of file memory.c.

{
    FIXME( "semi-stub: %p\n", node );
    *node = 0;
    return TRUE;
}

GetNumaNodeProcessorMaskEx()

BOOL WINAPI DECLSPEC_HOTPATCH GetNumaNodeProcessorMaskEx	(	USHORT	node,
		GROUP_AFFINITY *	mask
	)

Definition at line 1519 of file memory.c.

{
    FIXME( "stub: %hu %p\n", node, mask );
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

GetNumaProximityNodeEx()

BOOL WINAPI DECLSPEC_HOTPATCH GetNumaProximityNodeEx	(	ULONG	proximity_id,
		USHORT *	node
	)

Definition at line 1530 of file memory.c.

{
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

GetPhysicallyInstalledSystemMemory()

BOOL WINAPI DECLSPEC_HOTPATCH GetPhysicallyInstalledSystemMemory

(

ULONGLONG *

memory

)

Definition at line 1314 of file memory.c.

{
    MEMORYSTATUSEX status;
 
    if (!memory)
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    status.dwLength = sizeof(status);
    GlobalMemoryStatusEx( &status );
    *memory = status.ullTotalPhys / 1024;
    return TRUE;
}

GetSystemCpuSetInformation()

BOOL WINAPI GetSystemCpuSetInformation	(	SYSTEM_CPU_SET_INFORMATION *	info,
		ULONG	buffer_length,
		ULONG *	return_length,
		HANDLE	process,
		ULONG	flags
	)

Definition at line 1470 of file memory.c.

{
    if (flags)
        FIXME("Unsupported flags %#lx.\n", flags);
 
    *return_length = 0;
 
    return set_ntstatus( NtQuerySystemInformationEx( SystemCpuSetInformation, &process, sizeof(process), info,
            buffer_length, return_length ));
}

GetSystemFileCacheSize()

BOOL WINAPI DECLSPEC_HOTPATCH GetSystemFileCacheSize	(	SIZE_T *	mincache,
		SIZE_T *	maxcache,
		DWORD *	flags
	)

Definition at line 249 of file memory.c.

{
    FIXME( "stub: %p %p %p\n", mincache, maxcache, flags );
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

GetSystemFirmwareTable()

UINT WINAPI GetSystemFirmwareTable	(	DWORD	provider,
		DWORD	id,
		void *	buffer,
		DWORD	size
	)

Definition at line 1827 of file memory.c.

{
    TRACE( "(0x%08lx, 0x%08lx, %p, %ld)\n", provider, id, buffer, size );
 
    return get_firmware_table( provider, SystemFirmwareTable_Get, id, buffer, size );
}

GetSystemInfo()

void WINAPI DECLSPEC_HOTPATCH GetSystemInfo

(

SYSTEM_INFO *

si

)

Definition at line 231 of file memory.c.

{
    SYSTEM_BASIC_INFORMATION basic_info;
    SYSTEM_CPU_INFORMATION cpu_info;
 
    if (!set_ntstatus( NtQuerySystemInformation( SystemBasicInformation,
                                                 &basic_info, sizeof(basic_info), NULL )) ||
        !set_ntstatus( NtQuerySystemInformation( SystemCpuInformation,
                                                 &cpu_info, sizeof(cpu_info), NULL )))
        return;
 
    fill_system_info( si, &basic_info, &cpu_info );
}

Referenced by GetNativeSystemInfo().

GetWriteWatch()

UINT WINAPI DECLSPEC_HOTPATCH GetWriteWatch	(	DWORD	flags,
		void *	base,
		SIZE_T	size,
		void **	addresses,
		ULONG_PTR *	count,
		ULONG *	granularity
	)

Definition at line 260 of file memory.c.

{
    if (!set_ntstatus( NtGetWriteWatch( GetCurrentProcess(), flags, base, size,
                                        addresses, count, granularity )))
        return ~0u;
    return 0;
}

GlobalAlloc()

HGLOBAL WINAPI DECLSPEC_HOTPATCH GlobalAlloc	(	UINT	flags,
		SIZE_T	size
	)

Definition at line 951 of file memory.c.

{
    struct mem_entry *mem;
    HGLOBAL handle;
 
    /* LocalAlloc allows a 0-size fixed block, but GlobalAlloc doesn't */
    if (!(flags & GMEM_MOVEABLE) && !size) size = 1;
 
    handle = LocalAlloc( flags, size );
 
    if ((mem = unsafe_mem_from_HLOCAL( handle )) && (flags & GMEM_DDESHARE))
        mem->flags |= MEM_FLAG_DDESHARE;
 
    return handle;
}

GlobalFree()

HGLOBAL WINAPI DECLSPEC_HOTPATCH GlobalFree

(

HLOCAL

handle

)

Definition at line 971 of file memory.c.

{
    return LocalFree( handle );
}

GlobalMemoryStatusEx()

BOOL WINAPI DECLSPEC_HOTPATCH GlobalMemoryStatusEx

(

MEMORYSTATUSEX *

status

)

Definition at line 1333 of file memory.c.

{
    static MEMORYSTATUSEX cached_status;
    static DWORD last_check;
    SYSTEM_BASIC_INFORMATION basic_info;
    SYSTEM_PERFORMANCE_INFORMATION perf_info;
    VM_COUNTERS_EX vmc;
 
    if (status->dwLength != sizeof(*status))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    if ((NtGetTickCount() - last_check) < 1000)
    {
    *status = cached_status;
    return TRUE;
    }
    last_check = NtGetTickCount();
 
    if (!set_ntstatus( NtQuerySystemInformation( SystemBasicInformation,
                                                 &basic_info, sizeof(basic_info), NULL )) ||
        !set_ntstatus( NtQuerySystemInformation( SystemPerformanceInformation,
                                                 &perf_info, sizeof(perf_info), NULL)) ||
        !set_ntstatus( NtQueryInformationProcess( GetCurrentProcess(), ProcessVmCounters,
                                                  &vmc, sizeof(vmc), NULL )))
        return FALSE;
 
    status->dwMemoryLoad     = 0;
    status->ullTotalPhys     = basic_info.MmNumberOfPhysicalPages;
    status->ullAvailPhys     = perf_info.AvailablePages;
    status->ullTotalPageFile = perf_info.TotalCommitLimit;
    status->ullAvailPageFile = status->ullTotalPageFile - perf_info.TotalCommittedPages;
    status->ullTotalVirtual  = (ULONG_PTR)basic_info.HighestUserAddress - (ULONG_PTR)basic_info.LowestUserAddress + 1;
    status->ullAvailVirtual  = status->ullTotalVirtual - (ULONGLONG)vmc.WorkingSetSize /* approximate */;
    status->ullAvailExtendedVirtual = 0;
 
    status->ullTotalPhys     *= basic_info.PageSize;
    status->ullAvailPhys     *= basic_info.PageSize;
    status->ullTotalPageFile *= basic_info.PageSize;
    status->ullAvailPageFile *= basic_info.PageSize;
 
    if (status->ullTotalPhys)
        status->dwMemoryLoad = (status->ullTotalPhys - status->ullAvailPhys) / (status->ullTotalPhys / 100);
 
    TRACE_(virtual)( "MemoryLoad %lu, TotalPhys %I64u, AvailPhys %I64u, TotalPageFile %I64u, "
                     "AvailPageFile %I64u, TotalVirtual %I64u, AvailVirtual %I64u\n",
                     status->dwMemoryLoad, status->ullTotalPhys, status->ullAvailPhys, status->ullTotalPageFile,
                     status->ullAvailPageFile, status->ullTotalVirtual, status->ullAvailVirtual );
 
    cached_status = *status;
    return TRUE;
}

HeapCompact()

SIZE_T WINAPI DECLSPEC_HOTPATCH HeapCompact	(	HANDLE	heap,
		DWORD	flags
	)

Definition at line 716 of file memory.c.

{
    return RtlCompactHeap( heap, flags );
}

HeapCreate()

HANDLE WINAPI DECLSPEC_HOTPATCH HeapCreate	(	DWORD	flags,
		SIZE_T	init_size,
		SIZE_T	max_size
	)

Definition at line 725 of file memory.c.

{
    HANDLE ret = RtlCreateHeap( flags, NULL, max_size, init_size, NULL, NULL );
    if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
    return ret;
}

HeapDestroy()

BOOL WINAPI DECLSPEC_HOTPATCH HeapDestroy

(

HANDLE

heap

)

Definition at line 736 of file memory.c.

{
    if (!RtlDestroyHeap( heap )) return TRUE;
    SetLastError( ERROR_INVALID_HANDLE );
    return FALSE;
}

HeapLock()

BOOL WINAPI DECLSPEC_HOTPATCH HeapLock

(

HANDLE

heap

)

Definition at line 747 of file memory.c.

{
    return RtlLockHeap( heap );
}

HeapQueryInformation()

BOOL WINAPI HeapQueryInformation	(	HANDLE	heap,
		HEAP_INFORMATION_CLASS	info_class,
		PVOID	info,
		SIZE_T	size,
		PSIZE_T	size_out
	)

Definition at line 756 of file memory.c.

{
    return set_ntstatus( RtlQueryHeapInformation( heap, info_class, info, size, size_out ));
}

HeapSetInformation()

BOOL WINAPI HeapSetInformation	(	HANDLE	heap,
		HEAP_INFORMATION_CLASS	infoclass,
		PVOID	info,
		SIZE_T	size
	)

Definition at line 766 of file memory.c.

{
    return set_ntstatus( RtlSetHeapInformation( heap, infoclass, info, size ));
}

HeapUnlock()

BOOL WINAPI HeapUnlock

(

HANDLE

heap

)

Definition at line 775 of file memory.c.

{
    return RtlUnlockHeap( heap );
}

HeapValidate()

BOOL WINAPI DECLSPEC_HOTPATCH HeapValidate	(	HANDLE	heap,
		DWORD	flags,
		LPCVOID	ptr
	)

Definition at line 784 of file memory.c.

{
    return RtlValidateHeap( heap, flags, ptr );
}

Referenced by LocalFree(), and LocalReAlloc().

HeapWalk()

BOOL WINAPI DECLSPEC_HOTPATCH HeapWalk	(	HANDLE	heap,
		PROCESS_HEAP_ENTRY *	entry
	)

Definition at line 826 of file memory.c.

{
    struct rtl_heap_entry rtl_entry = {0};
    NTSTATUS status;
 
    if (!entry) return set_ntstatus( STATUS_INVALID_PARAMETER );
 
    rtl_entry.lpData = entry->lpData;
    rtl_entry.cbData = entry->cbData;
    rtl_entry.cbOverhead = entry->cbOverhead;
    rtl_entry.iRegionIndex = entry->iRegionIndex;
 
    if (entry->wFlags & PROCESS_HEAP_ENTRY_BUSY)
        rtl_entry.wFlags |= RTL_HEAP_ENTRY_BUSY;
    if (entry->wFlags & PROCESS_HEAP_REGION)
        rtl_entry.wFlags |= RTL_HEAP_ENTRY_REGION;
    if (entry->wFlags & PROCESS_HEAP_UNCOMMITTED_RANGE)
        rtl_entry.wFlags |= RTL_HEAP_ENTRY_UNCOMMITTED;
    memcpy( &rtl_entry.Region, &entry->Region, sizeof(entry->Region) );
 
    if (!(status = RtlWalkHeap( heap, &rtl_entry )))
    {
        entry->lpData = rtl_entry.lpData;
        entry->cbData = rtl_entry.cbData;
        entry->cbOverhead = rtl_entry.cbOverhead;
        entry->iRegionIndex = rtl_entry.iRegionIndex;
 
        if (rtl_entry.wFlags & RTL_HEAP_ENTRY_BUSY)
            entry->wFlags = PROCESS_HEAP_ENTRY_BUSY;
        else if (rtl_entry.wFlags & RTL_HEAP_ENTRY_REGION)
            entry->wFlags = PROCESS_HEAP_REGION;
        else if (rtl_entry.wFlags & RTL_HEAP_ENTRY_UNCOMMITTED)
            entry->wFlags = PROCESS_HEAP_UNCOMMITTED_RANGE;
        else
            entry->wFlags = 0;
 
        memcpy( &entry->Region, &rtl_entry.Region, sizeof(entry->Region) );
    }
 
    return set_ntstatus( status );
}

HLOCAL_from_mem()

static HLOCAL HLOCAL_from_mem ( struct mem_entry *  mem )

inlinestatic

Definition at line 919 of file memory.c.

{
    if (!mem) return 0;
    return &mem->ptr;
}

Referenced by LocalAlloc().

init_global_data()

void init_global_data

(

void

)

Definition at line 931 of file memory.c.

{
    global_data.mem_entries = VirtualAlloc( NULL, MAX_MEM_HANDLES * sizeof(struct mem_entry), MEM_COMMIT, PAGE_READWRITE );
    if (!(next_free_mem = global_data.mem_entries)) ERR( "Failed to allocate kernelbase global handle table\n" );
    global_data.mem_entries_end = global_data.mem_entries + MAX_MEM_HANDLES;
}

Referenced by DllMain().

InitializeContext()

BOOL WINAPI InitializeContext	(	void *	buffer,
		DWORD	context_flags,
		CONTEXT **	context,
		DWORD *	length
	)

Definition at line 1625 of file memory.c.

{
    return InitializeContext2( buffer, context_flags, context, length, ~(ULONG64)0 );
}

Referenced by DosBootsectorInitialize(), DosKRNLInitialize(), DosMouseInitialize(), DosStart(), InitializeBiosInt32(), and KsCreateDefaultAllocatorEx().

InitializeContext2()

BOOL WINAPI InitializeContext2	(	void *	buffer,
		DWORD	context_flags,
		CONTEXT **	context,
		DWORD *	length,
		ULONG64	compaction_mask
	)

Definition at line 1585 of file memory.c.

{
    ULONG orig_length;
    NTSTATUS status;
 
    TRACE( "buffer %p, context_flags %#lx, context %p, ret_length %p, compaction_mask %s.\n",
            buffer, context_flags, context, length, wine_dbgstr_longlong(compaction_mask) );
 
    orig_length = *length;
 
    if ((status = RtlGetExtendedContextLength2( context_flags, length, compaction_mask )))
    {
        if (status == STATUS_NOT_SUPPORTED && context_flags & 0x40)
        {
            context_flags &= ~0x40;
            status = RtlGetExtendedContextLength2( context_flags, length, compaction_mask );
        }
 
        if (status)
            return set_ntstatus( status );
    }
 
    if (!buffer || orig_length < *length)
    {
        SetLastError( ERROR_INSUFFICIENT_BUFFER );
        return FALSE;
    }
 
    if ((status = RtlInitializeExtendedContext2( buffer, context_flags, (CONTEXT_EX **)context, compaction_mask )))
        return set_ntstatus( status );
 
    *context = (CONTEXT *)((BYTE *)*context + (*(CONTEXT_EX **)context)->Legacy.Offset);
 
    return TRUE;
}

Referenced by InitializeContext().

is_exec_prot()

static BOOL is_exec_prot ( DWORD  protect )

static

Definition at line 449 of file memory.c.

{
    return protect == PAGE_EXECUTE || protect == PAGE_EXECUTE_READ || protect == PAGE_EXECUTE_READWRITE
            || protect == PAGE_EXECUTE_WRITECOPY;
}

Referenced by VirtualAlloc2FromApp(), and VirtualAllocFromApp().

IsBadStringPtrA()

BOOL WINAPI IsBadStringPtrA	(	LPCSTR	str,
		UINT_PTR	max
	)

Definition at line 673 of file memory.c.

{
    if (!str) return TRUE;
    __TRY
    {
        volatile const char *p = str;
        while (p != str + max) if (!*p++) break;
    }
    __EXCEPT_PAGE_FAULT
    {
        return TRUE;
    }
    __ENDTRY
    return FALSE;
}

IsBadStringPtrW()

BOOL WINAPI IsBadStringPtrW	(	LPCWSTR	str,
		UINT_PTR	max
	)

Definition at line 691 of file memory.c.

{
    if (!str) return TRUE;
    __TRY
    {
        volatile const WCHAR *p = str;
        while (p != str + max) if (!*p++) break;
    }
    __EXCEPT_PAGE_FAULT
    {
        return TRUE;
    }
    __ENDTRY
    return FALSE;
}

KernelBaseGetGlobalData()

void *WINAPI KernelBaseGetGlobalData

(

void

)

Definition at line 941 of file memory.c.

{
    WARN_(globalmem)( "semi-stub!\n" );
    return &global_data;
}

LocalAlloc()

HLOCAL WINAPI DECLSPEC_HOTPATCH LocalAlloc	(	UINT	flags,
		SIZE_T	size
	)

Definition at line 980 of file memory.c.

{
    DWORD heap_flags = 0x200 | HEAP_ADD_USER_INFO;
    HANDLE heap = GetProcessHeap();
    struct mem_entry *mem;
    HLOCAL handle;
    void *ptr;
 
    TRACE_(globalmem)( "flags %#x, size %#Ix\n", flags, size );
 
    if (flags & LMEM_ZEROINIT) heap_flags |= HEAP_ZERO_MEMORY;
 
    if (!(flags & LMEM_MOVEABLE)) /* pointer */
    {
        ptr = HeapAlloc( heap, heap_flags, size );
        if (ptr) RtlSetUserValueHeap( heap, heap_flags, ptr, ptr );
        TRACE_(globalmem)( "return %p\n", ptr );
        return ptr;
    }
 
    RtlLockHeap( heap );
    if ((mem = next_free_mem) < global_data.mem_entries || mem >= global_data.mem_entries_end)
        mem = NULL;
    else
    {
        if (!mem->next_free) next_free_mem++;
        else next_free_mem = mem->next_free;
        mem->next_free = NULL;
    }
    RtlUnlockHeap( heap );
 
    if (!mem) goto failed;
    handle = HLOCAL_from_mem( mem );
 
    mem->flags = MEM_FLAG_USED | MEM_FLAG_MOVEABLE;
    if (flags & LMEM_DISCARDABLE) mem->flags |= MEM_FLAG_DISCARDABLE;
    mem->lock  = 0;
    mem->ptr   = NULL;
 
    if (!size) mem->flags |= MEM_FLAG_DISCARDED;
    else
    {
        if (!(ptr = HeapAlloc( heap, heap_flags, size ))) goto failed;
        RtlSetUserValueHeap( heap, heap_flags, ptr, handle );
        mem->ptr = ptr;
    }
 
    TRACE_(globalmem)( "return handle %p, ptr %p\n", handle, mem->ptr );
    return handle;
 
failed:
    if (mem) LocalFree( *(volatile HANDLE *)&handle );
    SetLastError( ERROR_NOT_ENOUGH_MEMORY );
    return 0;
}

Referenced by Dns_AllocZero(), and GlobalAlloc().

LocalFree()

HLOCAL WINAPI DECLSPEC_HOTPATCH LocalFree

(

HLOCAL

handle

)

Definition at line 1040 of file memory.c.

{
    HANDLE heap = GetProcessHeap();
    struct mem_entry *mem;
    HLOCAL ret = handle;
    void *ptr;
 
    TRACE_(globalmem)( "handle %p\n", handle );
 
    RtlLockHeap( heap );
    if ((ptr = unsafe_ptr_from_HLOCAL( handle )) &&
        HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
    {
        if (HeapFree( heap, HEAP_NO_SERIALIZE, ptr )) ret = 0;
    }
    else if ((mem = unsafe_mem_from_HLOCAL( handle )))
    {
        if (HeapFree( heap, HEAP_NO_SERIALIZE, mem->ptr )) ret = 0;
        mem->ptr = NULL;
        mem->next_free = next_free_mem;
        next_free_mem = mem;
    }
    RtlUnlockHeap( heap );
 
    if (ret)
    {
        WARN_(globalmem)( "invalid handle %p\n", handle );
        SetLastError( ERROR_INVALID_HANDLE );
    }
    return ret;
}

Referenced by Dns_Free(), GlobalFree(), and LocalAlloc().

LocalLock()

LPVOID WINAPI DECLSPEC_HOTPATCH LocalLock

(

HLOCAL

handle

)

Definition at line 1076 of file memory.c.

{
    HANDLE heap = GetProcessHeap();
    struct mem_entry *mem;
    void *ret = NULL;
 
    TRACE_(globalmem)( "handle %p\n", handle );
 
    if (!handle) return NULL;
    if ((ret = unsafe_ptr_from_HLOCAL( handle )))
    {
        __TRY
        {
            volatile char *p = ret;
            *p |= 0;
        }
        __EXCEPT_PAGE_FAULT
        {
            return NULL;
        }
        __ENDTRY
        return ret;
    }
 
    RtlLockHeap( heap );
    if ((mem = unsafe_mem_from_HLOCAL( handle )))
    {
        if (!(ret = mem->ptr)) SetLastError( ERROR_DISCARDED );
        else if (!++mem->lock) mem->lock--;
    }
    else
    {
        WARN_(globalmem)( "invalid handle %p\n", handle );
        SetLastError( ERROR_INVALID_HANDLE );
    }
    RtlUnlockHeap( heap );
 
    return ret;
}

LocalReAlloc()

HLOCAL WINAPI DECLSPEC_HOTPATCH LocalReAlloc	(	HLOCAL	handle,
		SIZE_T	size,
		UINT	flags
	)

Definition at line 1120 of file memory.c.

{
    DWORD heap_flags = 0x200 | HEAP_ADD_USER_INFO | HEAP_NO_SERIALIZE;
    HANDLE heap = GetProcessHeap();
    struct mem_entry *mem;
    HLOCAL ret = 0;
    void *ptr;
 
    TRACE_(globalmem)( "handle %p, size %#Ix, flags %#x\n", handle, size, flags );
 
    if (flags & LMEM_ZEROINIT) heap_flags |= HEAP_ZERO_MEMORY;
 
    RtlLockHeap( heap );
    if ((ptr = unsafe_ptr_from_HLOCAL( handle )) &&
        HeapValidate( heap, HEAP_NO_SERIALIZE, ptr ))
    {
        if (flags & LMEM_MODIFY) ret = handle;
        else if (flags & LMEM_DISCARDABLE) SetLastError( ERROR_INVALID_PARAMETER );
        else
        {
            if (!(flags & LMEM_MOVEABLE)) heap_flags |= HEAP_REALLOC_IN_PLACE_ONLY;
            ret = HeapReAlloc( heap, heap_flags, ptr, size );
            if (ret) RtlSetUserValueHeap( heap, heap_flags, ret, ret );
            else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        }
    }
    else if ((mem = unsafe_mem_from_HLOCAL( handle )))
    {
        if (flags & LMEM_MODIFY)
        {
            if (flags & LMEM_DISCARDABLE) mem->flags |= MEM_FLAG_DISCARDABLE;
            ret = handle;
        }
        else if (flags & LMEM_DISCARDABLE) SetLastError( ERROR_INVALID_PARAMETER );
        else
        {
            if (size)
            {
                if (mem->lock && !(flags & LMEM_MOVEABLE)) heap_flags |= HEAP_REALLOC_IN_PLACE_ONLY;
                if (!mem->ptr) ptr = HeapAlloc( heap, heap_flags, size );
                else ptr = HeapReAlloc( heap, heap_flags, mem->ptr, size );
 
                if (!ptr) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
                else
                {
                    RtlSetUserValueHeap( heap, heap_flags, ptr, handle );
                    mem->flags &= ~MEM_FLAG_DISCARDED;
                    mem->ptr = ptr;
                    ret = handle;
                }
            }
            else if ((flags & LMEM_MOVEABLE) && !mem->lock)
            {
                HeapFree( heap, heap_flags, mem->ptr );
                mem->flags |= MEM_FLAG_DISCARDED;
                mem->ptr = NULL;
                ret = handle;
            }
            else SetLastError( ERROR_INVALID_PARAMETER );
        }
    }
    else SetLastError( ERROR_INVALID_HANDLE );
    RtlUnlockHeap( heap );
 
    return ret;
}

LocalUnlock()

BOOL WINAPI DECLSPEC_HOTPATCH LocalUnlock

(

HLOCAL

handle

)

Definition at line 1191 of file memory.c.

{
    HANDLE heap = GetProcessHeap();
    struct mem_entry *mem;
    BOOL ret = FALSE;
 
    TRACE_(globalmem)( "handle %p\n", handle );
 
    if (unsafe_ptr_from_HLOCAL( handle ))
    {
        SetLastError( ERROR_NOT_LOCKED );
        return FALSE;
    }
 
    RtlLockHeap( heap );
    if ((mem = unsafe_mem_from_HLOCAL( handle )))
    {
        if (mem->lock)
        {
            ret = (--mem->lock != 0);
            if (!ret) SetLastError( NO_ERROR );
        }
        else
        {
            WARN_(globalmem)( "handle %p not locked\n", handle );
            SetLastError( ERROR_NOT_LOCKED );
        }
    }
    else
    {
        WARN_(globalmem)( "invalid handle %p\n", handle );
        SetLastError( ERROR_INVALID_HANDLE );
    }
    RtlUnlockHeap( heap );
 
    return ret;
}

MapUserPhysicalPages()

BOOL WINAPI DECLSPEC_HOTPATCH MapUserPhysicalPages	(	void *	addr,
		ULONG_PTR	page_count,
		ULONG_PTR *	pages
	)

Definition at line 1391 of file memory.c.

{
    FIXME( "stub: %p %Iu %p\n", addr, page_count, pages );
    *pages = 0;
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

MapViewOfFile()

LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFile	(	HANDLE	mapping,
		DWORD	access,
		DWORD	offset_high,
		DWORD	offset_low,
		SIZE_T	count
	)

Definition at line 273 of file memory.c.

{
    return MapViewOfFileEx( mapping, access, offset_high, offset_low, count, NULL );
}

MapViewOfFile3()

LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFile3	(	HANDLE	handle,
		HANDLE	process,
		PVOID	baseaddr,
		ULONG64	offset,
		SIZE_T	size,
		ULONG	alloc_type,
		ULONG	protection,
		MEM_EXTENDED_PARAMETER *	params,
		ULONG	params_count
	)

Definition at line 326 of file memory.c.

{
    LARGE_INTEGER off;
    void *addr;
 
    if (!process) process = GetCurrentProcess();
 
    addr = baseaddr;
    off.QuadPart = offset;
    if (!set_ntstatus( NtMapViewOfSectionEx( handle, process, &addr, &off, &size, alloc_type, protection,
            params, params_count )))
    {
        return NULL;
    }
    return addr;
}

MapViewOfFileEx()

LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFileEx	(	HANDLE	handle,
		DWORD	access,
		DWORD	offset_high,
		DWORD	offset_low,
		SIZE_T	count,
		LPVOID	addr
	)

Definition at line 283 of file memory.c.

{
    NTSTATUS status;
    LARGE_INTEGER offset;
    ULONG protect;
    BOOL exec;
 
    offset.u.LowPart  = offset_low;
    offset.u.HighPart = offset_high;
 
    exec = access & FILE_MAP_EXECUTE;
    access &= ~FILE_MAP_EXECUTE;
 
    if (access == FILE_MAP_COPY)
        protect = exec ? PAGE_EXECUTE_WRITECOPY : PAGE_WRITECOPY;
    else if (access & FILE_MAP_WRITE)
        protect = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
    else if (access & FILE_MAP_READ)
        protect = exec ? PAGE_EXECUTE_READ : PAGE_READONLY;
    else protect = PAGE_NOACCESS;
 
    if ((status = NtMapViewOfSection( handle, GetCurrentProcess(), &addr, 0, 0, &offset,
                                      &count, ViewShare, 0, protect )) < 0)
    {
        SetLastError( RtlNtStatusToDosError(status) );
        addr = NULL;
    }
    return addr;
}

Referenced by MapViewOfFile(), and MapViewOfFileExNuma().

MapViewOfFileExNuma()

LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFileExNuma	(	HANDLE	handle,
		DWORD	access,
		DWORD	offset_high,
		DWORD	offset_low,
		SIZE_T	count,
		LPVOID	addr,
		DWORD	node
	)

Definition at line 1540 of file memory.c.

{
    if (node) FIXME( "Ignoring preferred node %lu\n", node );
    return MapViewOfFileEx( handle, access, offset_high, offset_low, count, addr );
}

MapViewOfFileFromApp()

LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFileFromApp	(	HANDLE	handle,
		ULONG	access,
		ULONG64	offset,
		SIZE_T	size
	)

Definition at line 318 of file memory.c.

{
    return MapViewOfFile( handle, access, offset << 32, offset, size );
}

open_cross_process_connection()

static CROSS_PROCESS_WORK_LIST * open_cross_process_connection ( HANDLE  process )

static

Definition at line 46 of file memory.c.

{
#ifdef __aarch64__
    CROSS_PROCESS_WORK_LIST *list;
    HANDLE section;
 
    RtlOpenCrossProcessEmulatorWorkConnection( process, &section, (void **)&list );
    if (section) NtClose( section );
    return list;
#else
    return NULL;
#endif
}

Referenced by FlushInstructionCache(), and WriteProcessMemory().

PrefetchVirtualMemory()

BOOL WINAPI DECLSPEC_HOTPATCH PrefetchVirtualMemory	(	HANDLE	process,
		ULONG_PTR	count,
		WIN32_MEMORY_RANGE_ENTRY *	addresses,
		ULONG	flags
	)

Definition at line 503 of file memory.c.

{
    return set_ntstatus( NtSetInformationVirtualMemory( process, VmPrefetchInformation,
                                                        count, (PMEMORY_RANGE_ENTRY)addresses,
                                                        &flags, sizeof(flags) ));
}

QueryMemoryResourceNotification()

BOOL WINAPI DECLSPEC_HOTPATCH QueryMemoryResourceNotification	(	HANDLE	handle,
		BOOL *	state
	)

Definition at line 1265 of file memory.c.

{
    switch (WaitForSingleObject( handle, 0 ))
    {
    case WAIT_OBJECT_0:
        *state = TRUE;
        return TRUE;
    case WAIT_TIMEOUT:
        *state = FALSE;
        return TRUE;
    }
    SetLastError( ERROR_INVALID_PARAMETER );
    return FALSE;
}

QueryVirtualMemoryInformation()

BOOL WINAPI DECLSPEC_HOTPATCH QueryVirtualMemoryInformation	(	HANDLE	process,
		const void *	addr,
		WIN32_MEMORY_INFORMATION_CLASS	info_class,
		void *	info,
		SIZE_T	size,
		SIZE_T *	ret_size
	)

Definition at line 1563 of file memory.c.

{
    switch (info_class)
    {
        case MemoryRegionInfo:
            return set_ntstatus( NtQueryVirtualMemory( process, addr, MemoryRegionInformation, info, size, ret_size ));
        default:
            FIXME("Unsupported info class %u.\n", info_class);
            return FALSE;
    }
}

ReadProcessMemory()

BOOL WINAPI DECLSPEC_HOTPATCH ReadProcessMemory	(	HANDLE	process,
		const void *	addr,
		void *	buffer,
		SIZE_T	size,
		SIZE_T *	bytes_read
	)

Definition at line 347 of file memory.c.

{
    return set_ntstatus( NtReadVirtualMemory( process, addr, buffer, size, bytes_read ));
}

ResetWriteWatch()

UINT WINAPI DECLSPEC_HOTPATCH ResetWriteWatch	(	void *	base,
		SIZE_T	size
	)

Definition at line 357 of file memory.c.

{
    if (!set_ntstatus( NtResetWriteWatch( GetCurrentProcess(), base, size )))
        return ~0u;
    return 0;
}

send_cross_process_notification()

static void send_cross_process_notification ( CROSS_PROCESS_WORK_LIST *  list, UINT  id, const void *  addr, SIZE_T  size, int  nb_args,   ...  )

static

Definition at line 65 of file memory.c.

{
#ifdef __aarch64__
    CROSS_PROCESS_WORK_ENTRY *entry;
    void *unused;
    va_list args;
    int i;
 
    if (!list) return;
    if ((entry = RtlWow64PopCrossProcessWorkFromFreeList( &list->free_list )))
    {
        entry->id = id;
        entry->addr = (ULONG_PTR)addr;
        entry->size = size;
        if (nb_args)
        {
            va_start( args, nb_args );
            for (i = 0; i < nb_args; i++) entry->args[i] = va_arg( args, int );
            va_end( args );
        }
        RtlWow64PushCrossProcessWorkOntoWorkList( &list->work_list, entry, &unused );
    }
#endif
}

Referenced by FlushInstructionCache(), and WriteProcessMemory().

SetProcessDefaultCpuSets()

BOOL WINAPI SetProcessDefaultCpuSets	(	HANDLE	process,
		const ULONG *	cpu_set_ids,
		ULONG	count
	)

Definition at line 1497 of file memory.c.

{
    FIXME( "process %p, cpu_set_ids %p, count %lu stub.\n", process, cpu_set_ids, count );
 
    return TRUE;
}

SetSystemFileCacheSize()

BOOL WINAPI DECLSPEC_HOTPATCH SetSystemFileCacheSize	(	SIZE_T	mincache,
		SIZE_T	maxcache,
		DWORD	flags
	)

Definition at line 368 of file memory.c.

{
    FIXME( "stub: %Id %Id %ld\n", mincache, maxcache, flags );
    SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return FALSE;
}

SetThreadSelectedCpuSets()

BOOL WINAPI SetThreadSelectedCpuSets	(	HANDLE	thread,
		const ULONG *	cpu_set_ids,
		ULONG	count
	)

Definition at line 1486 of file memory.c.

{
    FIXME( "thread %p, cpu_set_ids %p, count %lu stub.\n", thread, cpu_set_ids, count );
 
    return TRUE;
}

UnmapViewOfFile()

BOOL WINAPI DECLSPEC_HOTPATCH UnmapViewOfFile

(

const void *

addr

)

Definition at line 379 of file memory.c.

{
    if (GetVersion() & 0x80000000)
    {
        MEMORY_BASIC_INFORMATION info;
        if (!VirtualQuery( addr, &info, sizeof(info) ) || info.AllocationBase != addr)
        {
            SetLastError( ERROR_INVALID_ADDRESS );
            return FALSE;
        }
    }
    return set_ntstatus( NtUnmapViewOfSection( GetCurrentProcess(), (void *)addr ));
}

UnmapViewOfFile2()

BOOL WINAPI DECLSPEC_HOTPATCH UnmapViewOfFile2	(	HANDLE	process,
		void *	addr,
		ULONG	flags
	)

Definition at line 397 of file memory.c.

{
    return set_ntstatus( NtUnmapViewOfSectionEx( process, addr, flags ));
}

UnmapViewOfFileEx()

BOOL WINAPI DECLSPEC_HOTPATCH UnmapViewOfFileEx	(	void *	addr,
		ULONG	flags
	)

Definition at line 406 of file memory.c.

{
    return set_ntstatus( NtUnmapViewOfSectionEx( GetCurrentProcess(), addr, flags ));
}

unsafe_mem_from_HLOCAL()

static struct mem_entry * unsafe_mem_from_HLOCAL ( HLOCAL  handle )

inlinestatic

Definition at line 909 of file memory.c.

{
    struct mem_entry *mem = CONTAINING_RECORD( *(volatile HANDLE *)&handle, struct mem_entry, ptr );
    struct kernelbase_global_data *data = &global_data;
    if (((UINT_PTR)handle & ((sizeof(void *) << 1) - 1)) != sizeof(void *)) return NULL;
    if (mem < data->mem_entries || mem >= data->mem_entries_end) return NULL;
    if (!(mem->flags & MEM_FLAG_USED)) return NULL;
    return mem;
}

Referenced by GlobalAlloc(), LocalFree(), LocalLock(), LocalReAlloc(), and LocalUnlock().

unsafe_ptr_from_HLOCAL()

static void * unsafe_ptr_from_HLOCAL ( HLOCAL  handle )

inlinestatic

Definition at line 925 of file memory.c.

{
    if (((UINT_PTR)handle & ((sizeof(void *) << 1) - 1))) return NULL;
    return handle;
}

Referenced by LocalFree(), LocalLock(), LocalReAlloc(), and LocalUnlock().

VirtualAlloc()

LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAlloc	(	void *	addr,
		SIZE_T	size,
		DWORD	type,
		DWORD	protect
	)

Definition at line 415 of file memory.c.

{
    return VirtualAllocEx( GetCurrentProcess(), addr, size, type, protect );
}

Referenced by init_global_data().

VirtualAlloc2()

LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAlloc2	(	HANDLE	process,
		void *	addr,
		SIZE_T	size,
		DWORD	type,
		DWORD	protect,
		MEM_EXTENDED_PARAMETER *	parameters,
		ULONG	count
	)

Definition at line 437 of file memory.c.

{
    LPVOID ret = addr;
 
    if (!process) process = GetCurrentProcess();
    if (!set_ntstatus( NtAllocateVirtualMemoryEx( process, &ret, &size, type, protect, parameters, count )))
        return NULL;
    return ret;
}

VirtualAlloc2FromApp()

LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAlloc2FromApp	(	HANDLE	process,
		void *	addr,
		SIZE_T	size,
		DWORD	type,
		DWORD	protect,
		MEM_EXTENDED_PARAMETER *	parameters,
		ULONG	count
	)

Definition at line 458 of file memory.c.

{
    LPVOID ret = addr;
 
    TRACE_(virtual)( "addr %p, size %p, type %#lx, protect %#lx, params %p, count %lu.\n", addr, (void *)size, type, protect,
            parameters, count );
 
    if (is_exec_prot( protect ))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return NULL;
    }
 
    if (!process) process = GetCurrentProcess();
    if (!set_ntstatus( NtAllocateVirtualMemoryEx( process, &ret, &size, type, protect, parameters, count )))
        return NULL;
    return ret;
}

VirtualAllocEx()

LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocEx	(	HANDLE	process,
		void *	addr,
		SIZE_T	size,
		DWORD	type,
		DWORD	protect
	)

Definition at line 424 of file memory.c.

{
    LPVOID ret = addr;
 
    if (!set_ntstatus( NtAllocateVirtualMemory( process, &ret, 0, &size, type, protect ))) return NULL;
    return ret;
}

Referenced by VirtualAlloc(), and VirtualAllocExNuma().

VirtualAllocExNuma()

LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocExNuma	(	HANDLE	process,
		void *	addr,
		SIZE_T	size,
		DWORD	type,
		DWORD	protect,
		DWORD	node
	)

Definition at line 1552 of file memory.c.

{
    if (node) FIXME( "Ignoring preferred node %lu\n", node );
    return VirtualAllocEx( process, addr, size, type, protect );
}

VirtualAllocFromApp()

LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocFromApp	(	void *	addr,
		SIZE_T	size,
		DWORD	type,
		DWORD	protect
	)

Definition at line 482 of file memory.c.

{
    LPVOID ret = addr;
 
    TRACE_(virtual)( "addr %p, size %p, type %#lx, protect %#lx.\n", addr, (void *)size, type, protect );
 
    if (is_exec_prot( protect ))
    {
        SetLastError( ERROR_INVALID_PARAMETER );
        return NULL;
    }
 
    if (!set_ntstatus( NtAllocateVirtualMemory( GetCurrentProcess(), &ret, 0, &size, type, protect ))) return NULL;
    return ret;
}

VirtualFree()

BOOL WINAPI DECLSPEC_HOTPATCH VirtualFree	(	void *	addr,
		SIZE_T	size,
		DWORD	type
	)

Definition at line 515 of file memory.c.

{
    return VirtualFreeEx( GetCurrentProcess(), addr, size, type );
}

VirtualFreeEx()

BOOL WINAPI DECLSPEC_HOTPATCH VirtualFreeEx	(	HANDLE	process,
		void *	addr,
		SIZE_T	size,
		DWORD	type
	)

Definition at line 524 of file memory.c.

{
    if (type == MEM_RELEASE && size)
    {
        WARN( "Trying to release memory with specified size.\n" );
        SetLastError( ERROR_INVALID_PARAMETER );
        return FALSE;
    }
    return set_ntstatus( NtFreeVirtualMemory( process, &addr, &size, type ));
}

Referenced by VirtualFree().

VirtualLock()

BOOL WINAPI DECLSPEC_HOTPATCH VirtualLock	(	void *	addr,
		SIZE_T	size
	)

Definition at line 539 of file memory.c.

{
    return set_ntstatus( NtLockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 ));
}

VirtualProtect()

BOOL WINAPI DECLSPEC_HOTPATCH VirtualProtect	(	void *	addr,
		SIZE_T	size,
		DWORD	new_prot,
		DWORD *	old_prot
	)

Definition at line 548 of file memory.c.

{
    return VirtualProtectEx( GetCurrentProcess(), addr, size, new_prot, old_prot );
}

VirtualProtectEx()

BOOL WINAPI DECLSPEC_HOTPATCH VirtualProtectEx	(	HANDLE	process,
		void *	addr,
		SIZE_T	size,
		DWORD	new_prot,
		DWORD *	old_prot
	)

Definition at line 557 of file memory.c.

{
    DWORD prot;
 
    /* Win9x allows passing NULL as old_prot while this fails on NT */
    if (!old_prot && (GetVersion() & 0x80000000)) old_prot = &prot;
    return set_ntstatus( NtProtectVirtualMemory( process, &addr, &size, new_prot, old_prot ));
}

Referenced by VirtualProtect().

VirtualQuery()

SIZE_T WINAPI DECLSPEC_HOTPATCH VirtualQuery	(	LPCVOID	addr,
		PMEMORY_BASIC_INFORMATION	info,
		SIZE_T	len
	)

Definition at line 571 of file memory.c.

{
    return VirtualQueryEx( GetCurrentProcess(), addr, info, len );
}

Referenced by UnmapViewOfFile().

VirtualQueryEx()

SIZE_T WINAPI DECLSPEC_HOTPATCH VirtualQueryEx	(	HANDLE	process,
		LPCVOID	addr,
		PMEMORY_BASIC_INFORMATION	info,
		SIZE_T	len
	)

Definition at line 580 of file memory.c.

{
    SIZE_T ret;
 
    if (!set_ntstatus( NtQueryVirtualMemory( process, addr, MemoryBasicInformation, info, len, &ret )))
        return 0;
    return ret;
}

Referenced by VirtualQuery(), and WriteProcessMemory().

VirtualUnlock()

BOOL WINAPI DECLSPEC_HOTPATCH VirtualUnlock	(	void *	addr,
		SIZE_T	size
	)

Definition at line 594 of file memory.c.

{
    return set_ntstatus( NtUnlockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 ));
}

WINE_DECLARE_DEBUG_CHANNEL() [1/2]

WINE_DECLARE_DEBUG_CHANNEL

(

globalmem

)

WINE_DECLARE_DEBUG_CHANNEL() [2/2]

WINE_DECLARE_DEBUG_CHANNEL

(

virtual

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

heap

)

WriteProcessMemory()

BOOL WINAPI DECLSPEC_HOTPATCH WriteProcessMemory	(	HANDLE	process,
		void *	addr,
		const void *	buffer,
		SIZE_T	size,
		SIZE_T *	bytes_written
	)

Definition at line 603 of file memory.c.

{
    CROSS_PROCESS_WORK_LIST *list = open_cross_process_connection( process );
    DWORD old_prot, prot = PAGE_TARGETS_NO_UPDATE | PAGE_ENCLAVE_NO_CHANGE;
    MEMORY_BASIC_INFORMATION info;
    void *base_addr;
    SIZE_T region_size;
    NTSTATUS status, status2;
 
    if (!VirtualQueryEx( process, addr, &info, sizeof(info) ))
    {
        close_cross_process_connection( list );
        return FALSE;
    }
 
    switch (info.Protect & ~(PAGE_GUARD | PAGE_NOCACHE))
    {
    case PAGE_READWRITE:
    case PAGE_WRITECOPY:
    case PAGE_EXECUTE_READWRITE:
    case PAGE_EXECUTE_WRITECOPY:
        /* already writable */
        if ((status = NtWriteVirtualMemory( process, addr, buffer, size, bytes_written ))) break;
        send_cross_process_notification( list, CrossProcessFlushCache, addr, size, 0 );
        NtFlushInstructionCache( process, addr, size );
        break;
 
    case PAGE_EXECUTE:
    case PAGE_EXECUTE_READ:
        /* make it writable */
        base_addr = ROUND_ADDR( addr );
        region_size = ROUND_SIZE( addr, size );
        region_size = min( region_size,  (char *)info.BaseAddress + info.RegionSize - (char *)base_addr );
        prot |= (info.Type == MEM_PRIVATE) ? PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_WRITECOPY;
 
        send_cross_process_notification( list, CrossProcessPreVirtualProtect,
                                         base_addr, region_size, 1, prot );
        status = NtProtectVirtualMemory( process, &base_addr, &region_size, prot, &old_prot );
        send_cross_process_notification( list, CrossProcessPostVirtualProtect,
                                         base_addr, region_size, 2, prot, status );
        if (status) break;
 
        status = NtWriteVirtualMemory( process, addr, buffer, size, bytes_written );
        if (!status)
        {
            send_cross_process_notification( list, CrossProcessFlushCache, addr, size, 0 );
            NtFlushInstructionCache( process, addr, size );
        }
 
        prot = PAGE_TARGETS_NO_UPDATE | PAGE_ENCLAVE_NO_CHANGE | old_prot;
        send_cross_process_notification( list, CrossProcessPreVirtualProtect,
                                         base_addr, region_size, 1, prot );
        status2 = NtProtectVirtualMemory( process, &base_addr, &region_size, prot, &old_prot );
        send_cross_process_notification( list, CrossProcessPostVirtualProtect,
                                         base_addr, region_size, 2, prot, status2 );
        break;
 
    default:
        /* not writable */
        status = STATUS_ACCESS_VIOLATION;
        break;
    }
 
    close_cross_process_connection( list );
    return set_ntstatus( status );
}

Variable Documentation

global_data

struct kernelbase_global_data global_data = {0}

static

Definition at line 907 of file memory.c.

Referenced by init_global_data(), KernelBaseGetGlobalData(), LocalAlloc(), and unsafe_mem_from_HLOCAL().

next_free_mem

struct mem_entry* next_free_mem

static

Definition at line 906 of file memory.c.

Referenced by init_global_data(), LocalAlloc(), and LocalFree().

page_mask

const SIZE_T page_mask = 0xfff

static

Definition at line 96 of file memory.c.

Referenced by elf_map_file(), and macho_load_section_info().