//

// Copyright (c) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE file in the project root for full license information.

//

/*++

Module Name:

virtual.c

Abstract:

Implementation of virtual memory management functions.

--*/

#include "pal/thread.hpp"

#include "pal/cs.hpp"

#include "pal/malloc.hpp"

#include "pal/file.hpp"

#include "pal/dbgmsg.h"

#include "pal/virtual.h"

#include "pal/map.h"

#include "pal/init.h"

#include "common.h"

#include <sys/types.h>

#include <sys/mman.h>

#include <errno.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#if HAVE_VM_ALLOCATE

#include <mach/vm_map.h>

#include <mach/mach_init.h>

#endif // HAVE_VM_ALLOCATE

using namespace CorUnix;

SET_DEFAULT_DEBUG_CHANNEL(VIRTUAL);

CRITICAL_SECTION virtual_critsec PAL_GLOBAL;

CRITICAL_SECTION virtual_realloc PAL_GLOBAL;

#if MMAP_IGNORES_HINT

typedef struct FREE_BLOCK {

char *startBoundary;

SIZE_T memSize;

struct FREE_BLOCK *next;

} FREE_BLOCK;

#endif // MMAP_IGNORES_HINT

// The first node in our list of allocated blocks.

static PCMI pVirtualMemory;

#if MMAP_IGNORES_HINT

// The first node in our list of freed blocks.

static FREE_BLOCK *pFreeMemory PAL_GLOBAL;

// The amount of memory that we'll try to reserve on our file.

// Currently 1GB.

static const int BACKING_FILE_SIZE = 1024 * 1024 * 1024;

static void *VIRTUALReserveFromBackingFile(UINT_PTR addr, size_t length);

static BOOL VIRTUALAddToFreeList(const PCMI pMemoryToBeReleased);

// The base address of the pages mapped onto our backing file.

static void *gBackingBaseAddress = MAP_FAILED;

// Separate the subset of the feature for experiments

#define RESERVE_FROM_BACKING_FILE 1

#else

// static const void *gBackingBaseAddress = MAP_FAILED;

// #define RESERVE_FROM_BACKING_FILE 1

#endif

#if RESERVE_FROM_BACKING_FILE

static BOOL VIRTUALGetBackingFile(CPalThread * pthrCurrent);

// The file that we're using to back our pages.

static int gBackingFile PAL_GLOBAL = -1;

#endif // RESERVE_FROM_BACKING_FILE

/* We need MAP_ANON. However on some platforms like HP-UX, it is defined as MAP_ANONYMOUS */

#if !defined(MAP_ANON) && defined(MAP_ANONYMOUS)

#define MAP_ANON MAP_ANONYMOUS

#endif

/*++

Function:

ReserveVirtualMemory()

Helper function that is used by Virtual* APIs and ExecutableMemoryAllocator

to reserve virtual memory from the OS.

--*/

static LPVOID ReserveVirtualMemory(

IN CPalThread *pthrCurrent, /* Currently executing thread */

IN LPVOID lpAddress, /* Region to reserve or commit */

IN SIZE_T dwSize); /* Size of Region */

/*++

Function:

VIRTUALInitialize()

Initializes this section's critical section.

Return value:

TRUE if initialization succeeded

FALSE otherwise.

--*/

extern "C"

BOOL

VIRTUALInitialize( void )

{

TRACE( "Initializing the Virtual Critical Sections. \n" );

InternalInitializeCriticalSection(&virtual_critsec);

InternalInitializeCriticalSection(&virtual_realloc);

pVirtualMemory = NULL;

return TRUE;

}

/***

*

* VIRTUALCleanup()

* Deletes this section's critical section.

*

*/

extern "C"

void VIRTUALCleanup()

{

PCMI pEntry;

PCMI pTempEntry;

#if MMAP_IGNORES_HINT

FREE_BLOCK *pFreeBlock;

FREE_BLOCK *pTempFreeBlock;

#endif // MMAP_IGNORES_HINT

CPalThread * pthrCurrent = InternalGetCurrentThread();

InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);

// Clean up the allocated memory.

pEntry = pVirtualMemory;

while ( pEntry )

{

WARN( "The memory at %d was not freed through a call to VirtualFree.\n",

pEntry->startBoundary );

InternalFree(pEntry->pAllocState);

InternalFree(pEntry->pProtectionState );

#if MMAP_DOESNOT_ALLOW_REMAP

InternalFree(pEntry->pDirtyPages );

#endif

pTempEntry = pEntry;

pEntry = pEntry->pNext;

InternalFree(pTempEntry );

}

pVirtualMemory = NULL;

#if MMAP_IGNORES_HINT

// Clean up the free list.

pFreeBlock = pFreeMemory;

while (pFreeBlock != NULL)

{

// Ignore errors from munmap. There's nothing we'd really want to

// do about them.

munmap(pFreeBlock->startBoundary, pFreeBlock->memSize);

pTempFreeBlock = pFreeBlock;

pFreeBlock = pFreeBlock->next;

InternalFree(pTempFreeBlock);

}

pFreeMemory = NULL;

gBackingBaseAddress = MAP_FAILED;

#endif // MMAP_IGNORES_HINT

#if RESERVE_FROM_BACKING_FILE

if (gBackingFile != -1)

{

close(gBackingFile);

gBackingFile = -1;

}

#endif // RESERVE_FROM_BACKING_FILE

InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);

TRACE( "Deleting the Virtual Critical Sections. \n" );

DeleteCriticalSection( &virtual_critsec );

}

/***

*

* VIRTUALContainsInvalidProtectionFlags()

* Returns TRUE if an invalid flag is specified. FALSE otherwise.

*/

static BOOL VIRTUALContainsInvalidProtectionFlags( IN DWORD flProtect )

{

if ( ( flProtect & ~( PAGE_NOACCESS | PAGE_READONLY |

PAGE_READWRITE | PAGE_EXECUTE | PAGE_EXECUTE_READ |

PAGE_EXECUTE_READWRITE ) ) != 0 )

{

return TRUE;

}

else

{

return FALSE;

}

}

/****

*

* VIRTUALIsPageCommitted

*

* SIZE_T nBitToRetrieve - Which page to check.

*

* Returns TRUE if committed, FALSE otherwise.

*

*/

static BOOL VIRTUALIsPageCommitted( SIZE_T nBitToRetrieve, CONST PCMI pInformation )

{

SIZE_T nByteOffset = 0;

UINT nBitOffset = 0;

UINT byteMask = 0;

if ( !pInformation )

{

ERROR( "pInformation was NULL!\n" );

return FALSE;

}

nByteOffset = nBitToRetrieve / CHAR_BIT;

nBitOffset = nBitToRetrieve % CHAR_BIT;

byteMask = 1 << nBitOffset;

if ( pInformation->pAllocState[ nByteOffset ] & byteMask )

{

return TRUE;

}

else

{

return FALSE;

}

}

#if MMAP_DOESNOT_ALLOW_REMAP

/****

*

* VIRTUALIsPageDirty

*

* SIZE_T nBitToRetrieve - Which page to check.

*

* Returns TRUE if the page needs to be cleared if re-committed,

* FALSE otherwise.

*

*/

static BOOL VIRTUALIsPageDirty( SIZE_T nBitToRetrieve, CONST PCMI pInformation )

{

SIZE_T nByteOffset = 0;

UINT nBitOffset = 0;

UINT byteMask = 0;

if ( !pInformation )

{

ERROR( "pInformation was NULL!\n" );

return FALSE;

}

nByteOffset = nBitToRetrieve / CHAR_BIT;

nBitOffset = nBitToRetrieve % CHAR_BIT;

byteMask = 1 << nBitOffset;

if ( pInformation->pDirtyPages[ nByteOffset ] & byteMask )

{

return TRUE;

}

else

{

return FALSE;

}

}

#endif // MMAP_DOESNOT_ALLOW_REMAP

/*********

*

* VIRTUALGetAllocationType

*

* IN SIZE_T Index - The page within the range to retrieve

* the state for.

*

* IN pInformation - The virtual memory object.

*

*/

static INT VIRTUALGetAllocationType( SIZE_T Index, CONST PCMI pInformation )

{

if ( VIRTUALIsPageCommitted( Index, pInformation ) )

{

return MEM_COMMIT;

}

else

{

return MEM_RESERVE;

}

}

/****

*

* VIRTUALSetPageBits

*

* IN UINT nStatus - Bit set / reset [0: reset, any other value: set].

* IN SIZE_T nStartingBit - The bit to set.

*

* IN SIZE_T nNumberOfBits - The range of bits to set.

* IN BYTE* pBitArray - A pointer the array to be manipulated.

*

* Returns TRUE on success, FALSE otherwise.

* Turn on/off memory staus bits.

*

*/

static BOOL VIRTUALSetPageBits ( UINT nStatus, SIZE_T nStartingBit,

SIZE_T nNumberOfBits, BYTE * pBitArray )

{

/* byte masks for optimized modification of partial bytes (changing less

than 8 bits in a single byte). note that bits are treated in little

endian order : value 1 is bit 0; value 128 is bit 7. in the binary

representations below, bit 0 is on the right */

/* start masks : for modifying bits >= n while preserving bits < n.

example : if nStartignBit%8 is 3, then bits 0, 1, 2 remain unchanged

while bits 3..7 are changed; startmasks[3] can be used for this. */

static const BYTE startmasks[8] = {

0xff, /* start at 0 : 1111 1111 */

0xfe, /* start at 1 : 1111 1110 */

0xfc, /* start at 2 : 1111 1100 */

0xf8, /* start at 3 : 1111 1000 */

0xf0, /* start at 4 : 1111 0000 */

0xe0, /* start at 5 : 1110 0000 */

0xc0, /* start at 6 : 1100 0000 */

0x80 /* start at 7 : 1000 0000 */

};

/* end masks : for modifying bits <= n while preserving bits > n.

example : if the last bit to change is 5, then bits 6 & 7 stay unchanged

while bits 1..5 are changed; endmasks[5] can be used for this. */

static const BYTE endmasks[8] = {

0x01, /* end at 0 : 0000 0001 */

0x03, /* end at 1 : 0000 0011 */

0x07, /* end at 2 : 0000 0111 */

0x0f, /* end at 3 : 0000 1111 */

0x1f, /* end at 4 : 0001 1111 */

0x3f, /* end at 5 : 0011 1111 */

0x7f, /* end at 6 : 0111 1111 */

0xff /* end at 7 : 1111 1111 */

};

/* last example : if only the middle of a byte must be changed, both start

and end masks can be combined (bitwise AND) to obtain the correct mask.

if we want to change bits 2 to 4 :

startmasks[2] : 0xfc 1111 1100 (change 2,3,4,5,6,7)

endmasks[4]: 0x1f 0001 1111 (change 0,1,2,3,4)

bitwise AND : 0x1c 0001 1100 (change 2,3,4)

*/

BYTE byte_mask;

SIZE_T nLastBit;

SIZE_T nFirstByte;

SIZE_T nLastByte;

SIZE_T nFullBytes;

TRACE( "VIRTUALSetPageBits( nStatus = %d, nStartingBit = %d, "

"nNumberOfBits = %d, pBitArray = 0x%p )\n",

nStatus, nStartingBit, nNumberOfBits, pBitArray );

if ( 0 == nNumberOfBits )

{

ERROR( "nNumberOfBits was 0!\n" );

return FALSE;

}

nLastBit = nStartingBit+nNumberOfBits-1;

nFirstByte = nStartingBit / 8;

nLastByte = nLastBit / 8;

/* handle partial first byte (if any) */

if(0 != (nStartingBit % 8))

{

byte_mask = startmasks[nStartingBit % 8];

/* if 1st byte is the only changing byte, combine endmask to preserve

trailing bits (see 3rd example above) */

if( nLastByte == nFirstByte)

{

byte_mask &= endmasks[nLastBit % 8];

}

/* byte_mask contains 1 for bits to change, 0 for bits to leave alone */

if(0 == nStatus)

{

/* bits to change must be set to 0 : invert byte_mask (giving 0 for

bits to change), use bitwise AND */

pBitArray[nFirstByte] &= ~byte_mask;

}

else

{

/* bits to change must be set to 1 : use bitwise OR */

pBitArray[nFirstByte] |= byte_mask;

}

/* stop right away if only 1 byte is being modified */

if(nLastByte == nFirstByte)

{

return TRUE;

}

/* we're done with the 1st byte; skip over it */

nFirstByte++;

}

/* number of bytes to change, excluding the last byte (handled separately)*/

nFullBytes = nLastByte - nFirstByte;

if(0 != nFullBytes)

{

// Turn off/on dirty bits

memset( &(pBitArray[nFirstByte]), (0 == nStatus) ? 0 : 0xFF, nFullBytes );

}

/* handle last (possibly partial) byte */

byte_mask = endmasks[nLastBit % 8];

/* byte_mask contains 1 for bits to change, 0 for bits to leave alone */

if(0 == nStatus)

{

/* bits to change must be set to 0 : invert byte_mask (giving 0 for

bits to change), use bitwise AND */

pBitArray[nLastByte] &= ~byte_mask;

}

else

{

/* bits to change must be set to 1 : use bitwise OR */

pBitArray[nLastByte] |= byte_mask;

}

return TRUE;

}

/****

*

* VIRTUALSetAllocState

*

* IN UINT nAction - Which action to perform.

* IN SIZE_T nStartingBit - The bit to set.

*

* IN SIZE_T nNumberOfBits - The range of bits to set.

* IN PCMI pStateArray - A pointer the array to be manipulated.

*

* Returns TRUE on success, FALSE otherwise.

* Turn bit on to indicate committed, turn bit off to indicate reserved.

*

*/

static BOOL VIRTUALSetAllocState( UINT nAction, SIZE_T nStartingBit,

SIZE_T nNumberOfBits, CONST PCMI pInformation )

{

TRACE( "VIRTUALSetAllocState( nAction = %d, nStartingBit = %d, "

"nNumberOfBits = %d, pStateArray = 0x%p )\n",

nAction, nStartingBit, nNumberOfBits, pInformation );

if ( !pInformation )

{

ERROR( "pInformation was invalid!\n" );

return FALSE;

}

return VIRTUALSetPageBits((MEM_COMMIT == nAction) ? 1 : 0, nStartingBit,

nNumberOfBits, pInformation->pAllocState);

}

#if MMAP_DOESNOT_ALLOW_REMAP

/****

*

* VIRTUALSetDirtyPages

*

* IN UINT nStatus - 0: memory clean, any other value: memory is dirty

* IN SIZE_T nStartingBit - The bit to set.

*

* IN SIZE_T nNumberOfBits - The range of bits to set.

* IN PCMI pStateArray - A pointer the array to be manipulated.

*

* Returns TRUE on success, FALSE otherwise.

* Turns bit(s) on/off bit to indicate dirty page(s)

*

*/

static BOOL VIRTUALSetDirtyPages( UINT nStatus, SIZE_T nStartingBit,

SIZE_T nNumberOfBits, CONST PCMI pInformation )

{

TRACE( "VIRTUALSetDirtyPages( nStatus = %d, nStartingBit = %d, "

"nNumberOfBits = %d, pStateArray = 0x%p )\n",

nStatus, nStartingBit, nNumberOfBits, pInformation );

if ( !pInformation )

{

ERROR( "pInformation was invalid!\n" );

return FALSE;

}

return VIRTUALSetPageBits(nStatus, nStartingBit,

nNumberOfBits, pInformation->pDirtyPages);

}

#endif // MMAP_DOESNOT_ALLOW_REMAP

/****

*

* VIRTUALFindRegionInformation( )

*

* IN UINT_PTR address - The address to look for.

*

* Returns the PCMI if found, NULL otherwise.

*/

static PCMI VIRTUALFindRegionInformation( IN UINT_PTR address )

{

PCMI pEntry = NULL;

TRACE( "VIRTUALFindRegionInformation( %#x )\n", address );

pEntry = pVirtualMemory;

while( pEntry )

{

if ( pEntry->startBoundary > address )

{

/* Gone past the possible location in the list. */

pEntry = NULL;

break;

}

if ( pEntry->startBoundary + pEntry->memSize > address )

{

break;

}

pEntry = pEntry->pNext;

}

return pEntry;

}

/*++

Function :

VIRTUALOwnedRegion

Returns whether the space in question is owned the VIRTUAL system.

--*/

BOOL VIRTUALOwnedRegion( IN UINT_PTR address )

{

PCMI pEntry = NULL;

CPalThread * pthrCurrent = InternalGetCurrentThread();

InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);

pEntry = VIRTUALFindRegionInformation( address );

InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);

return pEntry != NULL;

}

/*++

Function :

VIRTUALReleaseMemory

Removes a PCMI entry from the list.

Returns true on success. FALSE otherwise.

--*/

static BOOL VIRTUALReleaseMemory( PCMI pMemoryToBeReleased )

{

BOOL bRetVal = TRUE;

if ( !pMemoryToBeReleased )

{

ASSERT( "Invalid pointer.\n" );

return FALSE;

}

if ( pMemoryToBeReleased == pVirtualMemory )

{

/* This is either the first entry, or the only entry. */

pVirtualMemory = pMemoryToBeReleased->pNext;

if ( pMemoryToBeReleased->pNext )

{

pMemoryToBeReleased->pNext->pLast = NULL;

}

}

else /* Could be anywhere in the list. */

{

/* Delete the entry from the linked list. */

if ( pMemoryToBeReleased->pLast )

{

pMemoryToBeReleased->pLast->pNext = pMemoryToBeReleased->pNext;

}

if ( pMemoryToBeReleased->pNext )

{

pMemoryToBeReleased->pNext->pLast = pMemoryToBeReleased->pLast;

}

}

#if MMAP_IGNORES_HINT

// We've removed the block from our allocated list. Add it to the

// free list.

bRetVal = VIRTUALAddToFreeList(pMemoryToBeReleased);

#endif // MMAP_IGNORES_HINT

InternalFree( pMemoryToBeReleased->pAllocState );

pMemoryToBeReleased->pAllocState = NULL;

InternalFree( pMemoryToBeReleased->pProtectionState );

pMemoryToBeReleased->pProtectionState = NULL;

#if MMAP_DOESNOT_ALLOW_REMAP

InternalFree( pMemoryToBeReleased->pDirtyPages );

pMemoryToBeReleased->pDirtyPages = NULL;

#endif // MMAP_DOESNOT_ALLOW_REMAP

InternalFree( pMemoryToBeReleased );

pMemoryToBeReleased = NULL;

return bRetVal;

}

/****

* VIRTUALConvertWinFlags() -

* Converts win32 protection flags to

* internal VIRTUAL flags.

*

*/

static BYTE VIRTUALConvertWinFlags( IN DWORD flProtect )

{

BYTE MemAccessControl = 0;

switch ( flProtect & 0xff )

{

case PAGE_NOACCESS :

MemAccessControl = VIRTUAL_NOACCESS;

break;

case PAGE_READONLY :

MemAccessControl = VIRTUAL_READONLY;

break;

case PAGE_READWRITE :

MemAccessControl = VIRTUAL_READWRITE;

break;

case PAGE_EXECUTE :

MemAccessControl = VIRTUAL_EXECUTE;

break;

case PAGE_EXECUTE_READ :

MemAccessControl = VIRTUAL_EXECUTE_READ;

break;

case PAGE_EXECUTE_READWRITE:

MemAccessControl = VIRTUAL_EXECUTE_READWRITE;

break;

default :

MemAccessControl = 0;

ERROR( "Incorrect or no protection flags specified.\n" );

break;

}

return MemAccessControl;

}

/****

* VIRTUALConvertVirtualFlags() -

* Converts internal virtual protection

* flags to their win32 counterparts.

*/

static DWORD VIRTUALConvertVirtualFlags( IN BYTE VirtualProtect )

{

DWORD MemAccessControl = 0;

if ( VirtualProtect == VIRTUAL_READONLY )

{

MemAccessControl = PAGE_READONLY;

}

else if ( VirtualProtect == VIRTUAL_READWRITE )

{

MemAccessControl = PAGE_READWRITE;

}

else if ( VirtualProtect == VIRTUAL_EXECUTE_READWRITE )

{

MemAccessControl = PAGE_EXECUTE_READWRITE;

}

else if ( VirtualProtect == VIRTUAL_EXECUTE_READ )

{

MemAccessControl = PAGE_EXECUTE_READ;

}

else if ( VirtualProtect == VIRTUAL_EXECUTE )

{

MemAccessControl = PAGE_EXECUTE;

}

else if ( VirtualProtect == VIRTUAL_NOACCESS )

{

MemAccessControl = PAGE_NOACCESS;

}

else

{

MemAccessControl = 0;

ERROR( "Incorrect or no protection flags specified.\n" );

}

return MemAccessControl;

}

/****

* VIRTUALStoreAllocationInfo()

*

* Stores the allocation information in the linked list.

* NOTE: The caller must own the critical section.

*/

static BOOL VIRTUALStoreAllocationInfo(

IN UINT_PTR startBoundary, /* Start of the region. */

IN SIZE_T memSize, /* Size of the region. */

IN DWORD flAllocationType, /* Allocation Types. */

IN DWORD flProtection ) /* Protections flags on the memory. */

{

PCMI pNewEntry = NULL;

PCMI pMemInfo = NULL;

BOOL bRetVal = TRUE;

SIZE_T nBufferSize = 0;

if ( ( memSize & VIRTUAL_PAGE_MASK ) != 0 )

{

ERROR( "The memory size was not in multiples of the page size. \n" );

bRetVal = FALSE;

goto done;

}

if ( !(pNewEntry = ( PCMI )InternalMalloc( sizeof( *pNewEntry )) ) )

{

ERROR( "Unable to allocate memory for the structure.\n");

bRetVal = FALSE;

goto done;

}

pNewEntry->startBoundary = startBoundary;

pNewEntry->memSize = memSize;

pNewEntry->allocationType = flAllocationType;

pNewEntry->accessProtection = flProtection;

nBufferSize = memSize / VIRTUAL_PAGE_SIZE / CHAR_BIT;

if ( ( memSize / VIRTUAL_PAGE_SIZE ) % CHAR_BIT != 0 )

{

nBufferSize++;

}

pNewEntry->pAllocState = (BYTE*)InternalMalloc( nBufferSize );

pNewEntry->pProtectionState = (BYTE*)InternalMalloc( (memSize / VIRTUAL_PAGE_SIZE) );

#if MMAP_DOESNOT_ALLOW_REMAP

pNewEntry->pDirtyPages = (BYTE*)InternalMalloc( nBufferSize );

#endif //

if ( pNewEntry->pAllocState && pNewEntry->pProtectionState

#if MMAP_DOESNOT_ALLOW_REMAP

&& pNewEntry->pDirtyPages

#endif // MMAP_DOESNOT_ALLOW_REMAP

)

{

/* Set the intial allocation state, and initial allocation protection. */

#if MMAP_DOESNOT_ALLOW_REMAP

memset (pNewEntry->pDirtyPages, 0, nBufferSize);

#endif // MMAP_DOESNOT_ALLOW_REMAP

VIRTUALSetAllocState( MEM_RESERVE, 0, nBufferSize * CHAR_BIT, pNewEntry );

memset( pNewEntry->pProtectionState,

VIRTUALConvertWinFlags( flProtection ),

memSize / VIRTUAL_PAGE_SIZE );

}

else

{

ERROR( "Unable to allocate memory for the structure.\n");

bRetVal = FALSE;

#if MMAP_DOESNOT_ALLOW_REMAP

if (pNewEntry->pDirtyPages) InternalFree( pNewEntry->pDirtyPages );

pNewEntry->pDirtyPages = NULL;

#endif //

if (pNewEntry->pProtectionState) InternalFree( pNewEntry->pProtectionState );

pNewEntry->pProtectionState = NULL;

if (pNewEntry->pAllocState) InternalFree( pNewEntry->pAllocState );

pNewEntry->pAllocState = NULL;

InternalFree( pNewEntry );

pNewEntry = NULL;

goto done;

}

pMemInfo = pVirtualMemory;

if ( pMemInfo && pMemInfo->startBoundary < startBoundary )

{

/* Look for the correct insert point */

TRACE( "Looking for the correct insert location.\n");

while ( pMemInfo->pNext && ( pMemInfo->pNext->startBoundary < startBoundary ) )

{

pMemInfo = pMemInfo->pNext;

}

pNewEntry->pNext = pMemInfo->pNext;

pNewEntry->pLast = pMemInfo;

if ( pNewEntry->pNext )

{

pNewEntry->pNext->pLast = pNewEntry;

}

pMemInfo->pNext = pNewEntry;

}

else

{

TRACE( "Inserting a new element into the linked list\n" );

/* This is the first entry in the list. */

pNewEntry->pNext = pMemInfo;

pNewEntry->pLast = NULL;

if ( pNewEntry->pNext )

{

pNewEntry->pNext->pLast = pNewEntry;

}

pVirtualMemory = pNewEntry ;

}

done:

TRACE( "Exiting StoreAllocationInformation. \n" );

return bRetVal;

}

/******

*

* VIRTUALReserveMemory() - Helper function that actually reserves the memory.

*

* NOTE: I call SetLastError in here, because many different error states

* exists, and that would be very complicated to work around.

*

*/

static LPVOID VIRTUALReserveMemory(

IN CPalThread *pthrCurrent, /* Currently executing thread */

IN LPVOID lpAddress, /* Region to reserve or commit */

IN SIZE_T dwSize, /* Size of Region */

IN DWORD flAllocationType, /* Type of allocation */

IN DWORD flProtect) /* Type of access protection */

{

LPVOID pRetVal = NULL;

UINT_PTR StartBoundary;

SIZE_T MemSize;

TRACE( "Reserving the memory now..\n");

// First, figure out where we're trying to reserve the memory and

// how much we need. On most systems, requests to mmap must be

// page-aligned and at multiples of the page size.

StartBoundary = (UINT_PTR)lpAddress & ~BOUNDARY_64K;

/* Add the sizes, and round down to the nearest page boundary. */

MemSize = ( ((UINT_PTR)lpAddress + dwSize + VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK ) -

StartBoundary;

if ((flAllocationType & MEM_RESERVE_EXECUTABLE) != 0)

{

fprintf(stderr, "MEM_RESERVE_EXECUTABLE is not supported!");

abort();

}

InternalEnterCriticalSection(pthrCurrent, &virtual_critsec);

if (pRetVal == NULL)

{

// Try to reserve memory from the OS

pRetVal = ReserveVirtualMemory(pthrCurrent, (LPVOID)StartBoundary, MemSize);

}

if (pRetVal != NULL)

{

#if !MMAP_IGNORES_HINT

if ( !lpAddress )

{

#endif // MMAP_IGNORES_HINT

/* Compute the real values instead of the null values. */

StartBoundary = (UINT_PTR)pRetVal & ~VIRTUAL_PAGE_MASK;

MemSize = ( ((UINT_PTR)pRetVal + dwSize + VIRTUAL_PAGE_MASK) & ~VIRTUAL_PAGE_MASK ) -

StartBoundary;

#if !MMAP_IGNORES_HINT

}

#endif // MMAP_IGNORES_HINT

if ( !VIRTUALStoreAllocationInfo( StartBoundary, MemSize,

flAllocationType, flProtect ) )

{

ASSERT( "Unable to store the structure in the list.\n");

pthrCurrent->SetLastError( ERROR_INTERNAL_ERROR );

munmap( pRetVal, MemSize );

pRetVal = NULL;

}

}

InternalLeaveCriticalSection(pthrCurrent, &virtual_critsec);

return pRetVal;

}

/******

*

* ReserveVirtualMemory() - Helper function that is used by Virtual* APIs

* and ExecutableMemoryAllocator to reserve virtual memory from the OS.

*

*/

static LPVOID ReserveVirtualMemory(

IN CPalThread *pthrCurrent, /* Currently executing thread */

IN LPVOID lpAddress, /* Region to reserve or commit */

IN SIZE_T dwSize) /* Size of Region */

{

LPVOID pRetVal = NULL;

#if !defined(__APPLE__) && !defined(vm_address_t)

#define vm_address_t UINT_PTR

#endif

vm_address_t StartBoundary = (vm_address_t)lpAddress;

SIZE_T MemSize = dwSize;

#if HAVE_VM_ALLOCATE

int result;

#endif // HAVE_VM_ALLOCATE

TRACE( "Reserving the memory now..\n");

#if MMAP_IGNORES_HINT

pRetVal = VIRTUALReserveFromBackingFile(StartBoundary, MemSize);

#else // MMAP_IGNORES_HINT

// Most platforms will only commit the memory if it is dirtied,

// so this should not consume too much swap space.

int mmapFlags = 0;

int mmapFile = -1;

off_t mmapOffset = 0;

#if HAVE_VM_ALLOCATE

// Allocate with vm_allocate first, then map at the fixed address.

result = vm_allocate(mach_task_self(), &StartBoundary, MemSize,

((LPVOID) StartBoundary != NULL) ? FALSE : TRUE);

if (result != KERN_SUCCESS) {

ERROR("vm_allocate failed to allocated the requested region!\n");

pthrCurrent->SetLastError(ERROR_INVALID_ADDRESS);

pRetVal = NULL;

goto done;

}

mmapFlags |= MAP_FIXED;

#endif // HAVE_VM_ALLOCATE

#if RESERVE_FROM_BACKING_FILE

mmapFile = gBackingFile;

mmapOffset = (char *) StartBoundary - (char *) gBackingBaseAddress;

mmapFlags |= MAP_PRIVATE;

#else // RESERVE_FROM_BACKING_FILE

mmapFlags |= MAP_ANON | MAP_PRIVATE;

#endif // RESERVE_FROM_BACKING_FILE

pRetVal = mmap((LPVOID) StartBoundary, MemSize, PROT_NONE,

mmapFlags, mmapFile, mmapOffset);

/* Check to see if the region is what we asked for. */

if (pRetVal != MAP_FAILED && lpAddress != NULL &&

StartBoundary != (UINT_PTR) pRetVal)

{

ERROR("We did not get the region we asked for!\n");

pthrCurrent->SetLastError(ERROR_INVALID_ADDRESS);

munmap(pRetVal, MemSize);

pRetVal = NULL;

goto done;

}

#endif // MMAP_IGNORES_HINT

if ( pRetVal != MAP_FAILED)

{

#if MMAP_ANON_IGNORES_PROTECTION

if (mprotect(pRetVal, MemSize, PROT_NONE) != 0)

{

ERROR("mprotect failed to protect the region!\n");

pthrCurrent->SetLastError(ERROR_INVALID_ADDRESS);

munmap(pRetVal, MemSize);

pRetVal = NULL;

goto done;

}

#endif // MMAP_ANON_IGNORES_PROTECTION

}

else

{

ERROR( "Failed due to insufficient memory.\n" );

#if HAVE_VM_ALLOCATE

vm_deallocate(mach_task_self(), StartBoundary, MemSize);