//

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

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

//

/*++

Module Name:

map.cpp

Abstract:

Implementation of file mapping API.

--*/

#include "pal/palinternal.h"

#include "pal/dbgmsg.h"

#include "pal/init.h"

#include "pal/critsect.h"

#include "pal/virtual.h"

#include "common.h"

#include "pal/map.hpp"

#include "pal/thread.hpp"

#include "pal/file.hpp"

#include "pal/malloc.hpp"

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/mman.h>

#include <unistd.h>

#include <errno.h>

#include "rt/ntimage.h"

#include <pal_endian.h>

using namespace CorUnix;

SET_DEFAULT_DEBUG_CHANNEL(VIRTUAL);

//

// The mapping critical section guards access to the list

// of currently mapped views. If a thread needs to access

// both this critical section and the data for an object

// it must acquire the object data first. That is, a thread

// cannot acquire any other locks after taking hold of

// this critical section.

//

CRITICAL_SECTION mapping_critsec PAL_GLOBAL;

LIST_ENTRY MappedViewList PAL_GLOBAL;

static PAL_ERROR MAPGrowLocalFile(INT, UINT);

static PMAPPED_VIEW_LIST MAPGetViewForAddress( LPCVOID );

static PAL_ERROR MAPDesiredAccessAllowed( DWORD, DWORD, DWORD );

static INT MAPProtectionToFileOpenFlags( DWORD );

static BOOL MAPIsRequestPermissible( DWORD, CFileProcessLocalData * );

static BOOL MAPContainsInvalidFlags( DWORD );

static DWORD MAPConvertProtectToAccess( DWORD );

static INT MAPFileMapToMmapFlags( DWORD );

static DWORD MAPMmapProtToAccessFlags( int prot );

#if ONE_SHARED_MAPPING_PER_FILEREGION_PER_PROCESS

static NativeMapHolder * NewNativeMapHolder(CPalThread *pThread, LPVOID address, SIZE_T size,

SIZE_T offset, long init_ref_count);

static LONG NativeMapHolderAddRef(NativeMapHolder * thisPMH);

static LONG NativeMapHolderRelease(CPalThread *pThread, NativeMapHolder * thisPMH);

static PMAPPED_VIEW_LIST FindSharedMappingReplacement(CPalThread *pThread, dev_t deviceNum, ino_t inodeNum,

SIZE_T size, SIZE_T offset);

#endif

static PAL_ERROR

MAPRecordMapping(

IPalObject *pMappingObject,

void *pPEBaseAddress,

void *addr,

size_t len,

int prot

);

static PAL_ERROR

MAPmmapAndRecord(

IPalObject *pMappingObject,

void *pPEBaseAddress,

void *addr,

size_t len,

int prot,

int flags,

int fd,

off_t offset,

LPVOID *ppvBaseAddress

);

#if !HAVE_MMAP_DEV_ZERO

/* 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

#endif

void

FileMappingCleanupRoutine(

CPalThread *pThread,

IPalObject *pObjectToCleanup,

bool fShutdown,

bool fCleanupSharedState

);

PAL_ERROR

FileMappingInitializationRoutine(

CPalThread *pThread,

CObjectType *pObjectType,

void *pImmutableData,

void *pSharedData,

void *pProcessLocalData

);

CObjectType CorUnix::otFileMapping PAL_GLOBAL(

otiFileMapping,

FileMappingCleanupRoutine,

FileMappingInitializationRoutine,

sizeof(CFileMappingImmutableData),

sizeof(CFileMappingProcessLocalData),

0,

PAGE_READWRITE | PAGE_READONLY | PAGE_WRITECOPY,

CObjectType::SecuritySupported,

CObjectType::SecurityInfoNotPersisted,

CObjectType::ObjectCanHaveName,

CObjectType::LocalDuplicationOnly,

CObjectType::UnwaitableObject,

CObjectType::SignalingNotApplicable,

CObjectType::ThreadReleaseNotApplicable,

CObjectType::OwnershipNotApplicable

);

CAllowedObjectTypes aotFileMapping PAL_GLOBAL (otiFileMapping);

void

FileMappingCleanupRoutine(

CPalThread *pThread,

IPalObject *pObjectToCleanup,

bool fShutdown,

bool fCleanupSharedState

)

{

PAL_ERROR palError = NO_ERROR;

CFileMappingImmutableData *pImmutableData = NULL;

CFileMappingProcessLocalData *pLocalData = NULL;

IDataLock *pLocalDataLock = NULL;

bool fDataChanged = FALSE;

if (TRUE == fCleanupSharedState)

{

//

// If we created a temporary file to back this mapping we need

// to unlink it now

//

palError = pObjectToCleanup->GetImmutableData(

reinterpret_cast<void**>(&pImmutableData)

);

if (NO_ERROR != palError)

{

ASSERT("Unable to obtain immutable data for object to be reclaimed");

return;

}

if (pImmutableData->bPALCreatedTempFile)

{

unlink(pImmutableData->szFileName);

}

}

if (FALSE == fShutdown)

{

//

// We only need to close the object's descriptor if we're not

// shutting down

//

palError = pObjectToCleanup->GetProcessLocalData(

pThread,

WriteLock,

&pLocalDataLock,

reinterpret_cast<void**>(&pLocalData)

);

if (NO_ERROR != palError)

{

ASSERT("Unable to obtain process local data for object to be reclaimed");

return;

}

if (-1 != pLocalData->UnixFd)

{

close(pLocalData->UnixFd);

pLocalData->UnixFd = -1;

fDataChanged = TRUE;

}

pLocalDataLock->ReleaseLock(pThread, fDataChanged);

}

//

// Why don't we need to deal with any views that may have been created

// from this mapping? If the process is shutting down then there's nothing

// that we need to take care of, as the OS will remove the underlying

// mappings when the process goes away. If we're not shutting down then

// there's no way for a view to exist against this mapping, since each

// view holds a reference against the mapping object.

//

}

PAL_ERROR

FileMappingInitializationRoutine(

CPalThread *pThread,

CObjectType *pObjectType,

void *pvImmutableData,

void *pvSharedData,

void *pvProcessLocalData

)

{

PAL_ERROR palError = NO_ERROR;

CFileMappingImmutableData *pImmutableData =

reinterpret_cast<CFileMappingImmutableData *>(pvImmutableData);

CFileMappingProcessLocalData *pProcessLocalData =

reinterpret_cast<CFileMappingProcessLocalData *>(pvProcessLocalData);

pProcessLocalData->UnixFd = InternalOpen(

pImmutableData->szFileName,

MAPProtectionToFileOpenFlags(pImmutableData->flProtect)

);

if (-1 == pProcessLocalData->UnixFd)

{

palError = ERROR_INTERNAL_ERROR;

goto ExitFileMappingInitializationRoutine;

}

#if ONE_SHARED_MAPPING_PER_FILEREGION_PER_PROCESS

struct stat st;

if (0 == fstat(pProcessLocalData->UnixFd, &st))

{

pProcessLocalData->MappedFileDevNum = st.st_dev;

pProcessLocalData->MappedFileInodeNum = st.st_ino;

}

else

{

ERROR("Couldn't get inode info for fd=%d to be stored in mapping object\n", pProcessLocalData->UnixFd);

}

#endif

ExitFileMappingInitializationRoutine:

return palError;

}

/*++

Function:

CreateFileMappingA

Note:

File mapping are used to do inter-process communication.

See MSDN doc.

--*/

HANDLE

PALAPI

CreateFileMappingA(

IN HANDLE hFile,

IN LPSECURITY_ATTRIBUTES lpFileMappingAttributes,

IN DWORD flProtect,

IN DWORD dwMaximumSizeHigh,

IN DWORD dwMaximumSizeLow,

IN LPCSTR lpName)

{

HANDLE hFileMapping = NULL;

CPalThread *pThread = NULL;

PAL_ERROR palError = NO_ERROR;

PERF_ENTRY(CreateFileMappingA);

ENTRY("CreateFileMappingA(hFile=%p, lpAttributes=%p, flProtect=%#x, "

"dwMaxSizeH=%d, dwMaxSizeL=%d, lpName=%p (%s))\n",

hFile, lpFileMappingAttributes, flProtect,

dwMaximumSizeHigh, dwMaximumSizeLow,

lpName?lpName:"NULL",

lpName?lpName:"NULL");

pThread = InternalGetCurrentThread();

if (lpName != nullptr)

{

ASSERT("lpName: Cross-process named objects are not supported in PAL");

palError = ERROR_NOT_SUPPORTED;

}

else

{

palError = InternalCreateFileMapping(

pThread,

hFile,

lpFileMappingAttributes,

flProtect,

dwMaximumSizeHigh,

dwMaximumSizeLow,

NULL,

&hFileMapping

);

}

//

// We always need to set last error, even on success:

// we need to protect ourselves from the situation

// where last error is set to ERROR_ALREADY_EXISTS on

// entry to the function

//

pThread->SetLastError(palError);

LOGEXIT( "CreateFileMappingA returns HANDLE %p. \n", hFileMapping );

PERF_EXIT(CreateFileMappingA);

return hFileMapping;

}

/*++

Function:

CreateFileMappingW

Note:

File mapping are used to do inter-process communication.

See MSDN doc.

--*/

HANDLE

PALAPI

CreateFileMappingW(

IN HANDLE hFile,

IN LPSECURITY_ATTRIBUTES lpFileMappingAttributes,

IN DWORD flProtect,

IN DWORD dwMaximumSizeHigh,

IN DWORD dwMaximumSizeLow,

IN LPCWSTR lpName)

{

HANDLE hFileMapping = NULL;

CPalThread *pThread = NULL;

PAL_ERROR palError = NO_ERROR;

PERF_ENTRY(CreateFileMappingW);

ENTRY("CreateFileMappingW(hFile=%p, lpAttributes=%p, flProtect=%#x, "

"dwMaxSizeH=%u, dwMaxSizeL=%u, lpName=%p (%S))\n",

hFile, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh,

dwMaximumSizeLow, lpName?lpName:W16_NULLSTRING, lpName?lpName:W16_NULLSTRING);

pThread = InternalGetCurrentThread();

palError = InternalCreateFileMapping(

pThread,

hFile,

lpFileMappingAttributes,

flProtect,

dwMaximumSizeHigh,

dwMaximumSizeLow,

lpName,

&hFileMapping

);

//

// We always need to set last error, even on success:

// we need to protect ourselves from the situation

// where last error is set to ERROR_ALREADY_EXISTS on

// entry to the function

//

pThread->SetLastError(palError);

LOGEXIT( "CreateFileMappingW returning %p .\n", hFileMapping );

PERF_EXIT(CreateFileMappingW);

return hFileMapping;

}

PAL_ERROR

CorUnix::InternalCreateFileMapping(

CPalThread *pThread,

HANDLE hFile,

LPSECURITY_ATTRIBUTES lpFileMappingAttributes,

DWORD flProtect,

DWORD dwMaximumSizeHigh,

DWORD dwMaximumSizeLow,

LPCWSTR lpName,

HANDLE *phMapping

)

{

CObjectAttributes objectAttributes(lpName, lpFileMappingAttributes);

PAL_ERROR palError = NO_ERROR;

IPalObject *pMapping = NULL;

IPalObject *pRegisteredMapping = NULL;

CFileMappingProcessLocalData *pLocalData = NULL;

IDataLock *pLocalDataLock = NULL;

CFileMappingImmutableData *pImmutableData = NULL;

IPalObject *pFileObject = NULL;

CFileProcessLocalData *pFileLocalData = NULL;

IDataLock *pFileLocalDataLock = NULL;

struct stat UnixFileInformation;

INT UnixFd = -1;

BOOL bPALCreatedTempFile = FALSE;

UINT nFileSize = 0;

//

// Validate parameters

//

if (lpName != nullptr)

{

ASSERT("lpName: Cross-process named objects are not supported in PAL");

palError = ERROR_NOT_SUPPORTED;

goto ExitInternalCreateFileMapping;

}

if (0 != dwMaximumSizeHigh)

{

ASSERT("dwMaximumSizeHigh is always 0.\n");

palError = ERROR_INVALID_PARAMETER;

goto ExitInternalCreateFileMapping;

}

if (PAGE_READWRITE != flProtect

&& PAGE_READONLY != flProtect

&& PAGE_WRITECOPY != flProtect)

{

ASSERT( "invalid flProtect %#x, acceptable values are PAGE_READONLY "

"(%#x), PAGE_READWRITE (%#x) and PAGE_WRITECOPY (%#x).\n",

flProtect, PAGE_READONLY, PAGE_READWRITE, PAGE_WRITECOPY );

palError = ERROR_INVALID_PARAMETER;

goto ExitInternalCreateFileMapping;

}

if (hFile == INVALID_HANDLE_VALUE && 0 == dwMaximumSizeLow)

{

ERROR( "If hFile is INVALID_HANDLE_VALUE, then you must specify a size.\n" );

palError = ERROR_INVALID_PARAMETER;

goto ExitInternalCreateFileMapping;

}

if (hFile != INVALID_HANDLE_VALUE && NULL != lpName)

{

ASSERT( "If hFile is not -1, then lpName must be NULL.\n" );

palError = ERROR_INVALID_PARAMETER;

goto ExitInternalCreateFileMapping;

}

palError = g_pObjectManager->AllocateObject(

pThread,

&otFileMapping,

&objectAttributes,

&pMapping

);

if (NO_ERROR != palError)

{

goto ExitInternalCreateFileMapping;

}

palError = pMapping->GetImmutableData(reinterpret_cast<void**>(&pImmutableData));

if (NO_ERROR != palError)

{

goto ExitInternalCreateFileMapping;

}

if (hFile == INVALID_HANDLE_VALUE)

{

//

// Note: this path is what prevents us supporting the

// duplication of file mapping objects across processes, since

// there is no backing file that the other process can open. We can

// avoid this restriction by always using a temp backing file for

// anonymous mappings.

//

/* Anonymous mapped files. */

if (strcpy_s(pImmutableData->szFileName, sizeof(pImmutableData->szFileName), "/dev/zero") != SAFECRT_SUCCESS)

{

ERROR( "strcpy_s failed!\n" );

palError = ERROR_INTERNAL_ERROR;

goto ExitInternalCreateFileMapping;

}

#if HAVE_MMAP_DEV_ZERO

UnixFd = InternalOpen(pImmutableData->szFileName, O_RDWR);

if ( -1 == UnixFd )

{

ERROR( "Unable to open the file.\n");

palError = ERROR_INTERNAL_ERROR;

goto ExitInternalCreateFileMapping;

}

#else //!HAVE_MMAP_DEV_ZERO

UnixFd = -1; /* will pass MAP_ANON to mmap() instead */

#endif //!HAVE_MMAP_DEV_ZERO

}

else

{

if ( hFile != INVALID_HANDLE_VALUE )

{

palError = g_pObjectManager->ReferenceObjectByHandle(

pThread,

hFile,

&aotFile,

GENERIC_READ,

&pFileObject

);

if (NO_ERROR != palError)

{

ERROR("Unable to obtain file data.\n");

palError = ERROR_INVALID_PARAMETER;

goto ExitInternalCreateFileMapping;

}

palError = pFileObject->GetProcessLocalData(

pThread,

ReadLock,

&pFileLocalDataLock,

reinterpret_cast<void**>(&pFileLocalData)

);

if (NO_ERROR != palError)

{

goto ExitInternalCreateFileMapping;

}

/* We need to check to ensure flProtect jives with

the permission on the file handle */

if (!MAPIsRequestPermissible(flProtect, pFileLocalData))

{

ERROR("File handle does not have the correct "

"permissions to create mapping\n" );

palError = ERROR_ACCESS_DENIED;

if (NULL != pFileLocalDataLock)

{

pFileLocalDataLock->ReleaseLock(pThread, FALSE);

}

goto ExitInternalCreateFileMapping;

}

//

// TODO: technically, the file mapping object should hold

// a reference to the passed in file object. This implementation

// only keeps the underlying native file structure (i.e., what

// the duplicated descriptors point to) open. There may be a risk

// here pertaining to the file lock information that the PAL must

// maintain (e.g,. if the passed in handle is closed immediately

// after the file mapping is opened then the lock information will

// be released, since we're not doing anything to keep it alive

// here).

//

// Having a direct reference to the underlying file object adds

// some complication, especially in cross-process cases. We may

// want to consider adding a reference to the PAL's file lock

// information, though...

//

UnixFd = dup(pFileLocalData->unix_fd);

if (-1 == UnixFd)

{

ERROR( "Unable to duplicate the Unix file descriptor!\n" );

palError = ERROR_INTERNAL_ERROR;

if (NULL != pFileLocalDataLock)

{

pFileLocalDataLock->ReleaseLock(pThread, FALSE);

}

goto ExitInternalCreateFileMapping;

}

if (strcpy_s(pImmutableData->szFileName, sizeof(pImmutableData->szFileName), pFileLocalData->unix_filename) != SAFECRT_SUCCESS)

{

ERROR( "strcpy_s failed!\n" );

palError = ERROR_INTERNAL_ERROR;

if (NULL != pFileLocalDataLock)

{

pFileLocalDataLock->ReleaseLock(pThread, FALSE);

}

goto ExitInternalCreateFileMapping;

}

if (NULL != pFileLocalDataLock)

{

pFileLocalDataLock->ReleaseLock(pThread, FALSE);

}

}

else

{

ASSERT("should not get here\n");

palError = ERROR_INTERNAL_ERROR;

goto ExitInternalCreateFileMapping;

}

if (-1 == fstat(UnixFd, &UnixFileInformation))

{

ASSERT("fstat() failed for this reason %s.\n", strerror(errno));

palError = ERROR_INTERNAL_ERROR;

goto ExitInternalCreateFileMapping;

}

if ( 0 == UnixFileInformation.st_size &&

0 == dwMaximumSizeHigh && 0 == dwMaximumSizeLow )

{

ERROR( "The file cannot be a zero length file.\n" );

palError = ERROR_FILE_INVALID;

goto ExitInternalCreateFileMapping;

}

if ( INVALID_HANDLE_VALUE != hFile &&

dwMaximumSizeLow > (DWORD) UnixFileInformation.st_size &&

( PAGE_READONLY == flProtect || PAGE_WRITECOPY == flProtect ) )

{

/* In this situation, Windows returns an error, because the

permissions requested do not allow growing the file */

ERROR( "The file cannot be grown do to the map's permissions.\n" );

palError = ERROR_NOT_ENOUGH_MEMORY;

goto ExitInternalCreateFileMapping;

}

if ( (DWORD) UnixFileInformation.st_size < dwMaximumSizeLow )

{

TRACE( "Growing the size of file on disk to match requested size.\n" );

/* Need to grow the file on disk to match size. */

palError = MAPGrowLocalFile(UnixFd, dwMaximumSizeLow);

if (NO_ERROR != palError)

{

ERROR( "Unable to grow the file on disk.\n" );

goto ExitInternalCreateFileMapping;

}

}

}

nFileSize = ( 0 == dwMaximumSizeLow && 0 == dwMaximumSizeHigh ) ?

UnixFileInformation.st_size : dwMaximumSizeLow;

pImmutableData->MaxSize = nFileSize;

pImmutableData->flProtect = flProtect;

pImmutableData->bPALCreatedTempFile = bPALCreatedTempFile;

pImmutableData->dwDesiredAccessWhenOpened = MAPConvertProtectToAccess(flProtect);

//

// The local data isn't grabbed / modified until here so that we don't

// need to worry ourselves with locking issues with the passed in

// file handle -- all operations concerning the file handle are completed

// before we deal with the lock for the new object.

//

palError = pMapping->GetProcessLocalData(

pThread,

WriteLock,

&pLocalDataLock,

reinterpret_cast<void**>(&pLocalData)

);

if (NO_ERROR != palError)

{

goto ExitInternalCreateFileMapping;

}

pLocalData->UnixFd = UnixFd;

#if ONE_SHARED_MAPPING_PER_FILEREGION_PER_PROCESS

if (-1 == UnixFd)

{

pLocalData->MappedFileDevNum = (dev_t)-1; /* there is no standard NO_DEV */

pLocalData->MappedFileInodeNum = NO_INO;

}

else

{

struct stat st;

if (0 == fstat(UnixFd, &st))

{

pLocalData->MappedFileDevNum = st.st_dev;

pLocalData->MappedFileInodeNum = st.st_ino;

}

else

{

ERROR("Couldn't get inode info for fd=%d to be stored in mapping object\n", UnixFd);

palError = ERROR_INTERNAL_ERROR;

goto ExitInternalCreateFileMapping;

}

}

#endif

pLocalDataLock->ReleaseLock(pThread, TRUE);

pLocalDataLock = NULL;

palError = g_pObjectManager->RegisterObject(

pThread,

pMapping,

&aotFileMapping,

flProtect, // TODO: is flProtect really an access right?

phMapping,

&pRegisteredMapping

);

//

// pMapping is invalidated by the call to RegisterObject, so NULL it

// out here to ensure that we don't try to release a reference on

// it down the line. This also ensures that we won't attempt to release

// any data associated with the mapping object here, as if any cleanup is

// necessary due to a failure in RegisterObject (which includes another

// object by the same name already existing) the cleanup will take place

// when that routine releases the reference to pMapping.

//

pMapping = NULL;

ExitInternalCreateFileMapping:

if (NULL != pLocalDataLock)

{

pLocalDataLock->ReleaseLock(

pThread,

TRUE

);

}

if (NULL != pMapping)

{

pMapping->ReleaseReference(pThread);

if (bPALCreatedTempFile)

{

unlink(pImmutableData->szFileName);

}

if (-1 != UnixFd)

{

close(UnixFd);

}

}

if (NULL != pRegisteredMapping)

{

pRegisteredMapping->ReleaseReference(pThread);

}

if (NULL != pFileObject)

{

pFileObject->ReleaseReference(pThread);

}

return palError;

}

/*++

Function:

OpenFileMappingA

See MSDN doc.

--*/

HANDLE

PALAPI

OpenFileMappingA(

IN DWORD dwDesiredAccess,

IN BOOL bInheritHandle,

IN LPCSTR lpName)

{

HANDLE hFileMapping = NULL;

CPalThread *pThread = NULL;

PAL_ERROR palError = NO_ERROR;

PERF_ENTRY(OpenFileMappingA);

ENTRY("OpenFileMappingA(dwDesiredAccess=%u, bInheritHandle=%d, lpName=%p (%s)\n",

dwDesiredAccess, bInheritHandle, lpName?lpName:"NULL", lpName?lpName:"NULL");

pThread = InternalGetCurrentThread();

if (lpName == nullptr)

{

ERROR("name is NULL\n");

palError = ERROR_INVALID_PARAMETER;

}

else

{

ASSERT("lpName: Cross-process named objects are not supported in PAL");

palError = ERROR_NOT_SUPPORTED;

}

if (NO_ERROR != palError)

{

pThread->SetLastError(palError);

}

LOGEXIT( "OpenFileMappingA returning %p\n", hFileMapping );

PERF_EXIT(OpenFileMappingA);

return hFileMapping;

}

/*++

Function:

OpenFileMappingW

See MSDN doc.

--*/

HANDLE

PALAPI

OpenFileMappingW(

IN DWORD dwDesiredAccess,

IN BOOL bInheritHandle,

IN LPCWSTR lpName)

{

HANDLE hFileMapping = NULL;

PAL_ERROR palError = NO_ERROR;

CPalThread *pThread = NULL;

PERF_ENTRY(OpenFileMappingW);

ENTRY("OpenFileMappingW(dwDesiredAccess=%#x, bInheritHandle=%d, lpName=%p (%S)\n",

dwDesiredAccess, bInheritHandle, lpName?lpName:W16_NULLSTRING, lpName?lpName:W16_NULLSTRING);

pThread = InternalGetCurrentThread();

/* validate parameters */

if (lpName == nullptr)

{

ERROR("name is NULL\n");

palError = ERROR_INVALID_PARAMETER;

}

else

{

ASSERT("lpName: Cross-process named objects are not supported in PAL");

palError = ERROR_NOT_SUPPORTED;

}

if (NO_ERROR != palError)

{

pThread->SetLastError(palError);

}

LOGEXIT("OpenFileMappingW returning %p.\n", hFileMapping);

PERF_EXIT(OpenFileMappingW);

return hFileMapping;

}

PAL_ERROR

CorUnix::InternalOpenFileMapping(

CPalThread *pThread,

DWORD dwDesiredAccess,

BOOL bInheritHandle,

LPCWSTR lpName,

HANDLE *phMapping

)

{

PAL_ERROR palError = NO_ERROR;

IPalObject *pFileMapping = NULL;

CPalString sObjectName(lpName);

if ( MAPContainsInvalidFlags( dwDesiredAccess ) )

{

ASSERT( "dwDesiredAccess can be one or more of FILE_MAP_READ, "

"FILE_MAP_WRITE, FILE_MAP_COPY or FILE_MAP_ALL_ACCESS.\n" );

palError = ERROR_INVALID_PARAMETER;

goto ExitInternalOpenFileMapping;

}

palError = g_pObjectManager->LocateObject(

pThread,

&sObjectName,

&aotFileMapping,

&pFileMapping

);

if (NO_ERROR != palError)

{

goto ExitInternalOpenFileMapping;

}

palError = g_pObjectManager->ObtainHandleForObject(

pThread,

pFileMapping,

dwDesiredAccess,

bInheritHandle,

NULL,

phMapping

);

if (NO_ERROR != palError)

{

goto ExitInternalOpenFileMapping;

}

ExitInternalOpenFileMapping:

if (NULL != pFileMapping)

{

pFileMapping->ReleaseReference(pThread);

}

return palError;

}

/*++

Function:

MapViewOfFile

Limitations: 1) Currently file mappings are supported only at file

offset 0.

2) Some platforms (specifically HP-UX) do not support

multiple simultaneous shared mapping of the same file

region in the same process. On these platforms, in case

we are asked for a new view completely contained in an

existing one, we return an address within the existing

mapping. In case the new requested view is overlapping

with the existing one, but not contained in it, the

mapping is impossible, and MapViewOfFile will fail.

Since currently the mappings are supported only at file

offset 0, MapViewOfFile will succeed if the new view

is equal or smaller of the existing one, and the address

returned will be the same address of the existing

mapping.

Since the underlying mapping is always the same, all

the shared views of the same file region will share the

same protection, i.e. they will have the largest

protection requested. If any mapping asked for a

read-write access, all the read-only mappings of the

same region will silently get a read-write access to

it.

See MSDN doc.

--*/

LPVOID

PALAPI

MapViewOfFile(

IN HANDLE hFileMappingObject,

IN DWORD dwDesiredAccess,

IN DWORD dwFileOffsetHigh,

IN DWORD dwFileOffsetLow,

IN SIZE_T dwNumberOfBytesToMap)

{

PAL_ERROR palError = NO_ERROR;

CPalThread *pThread = NULL;

LPVOID pvMappedBaseAddress = NULL;

PERF_ENTRY(MapViewOfFile);

ENTRY("MapViewOfFile(hFileMapping=%p, dwDesiredAccess=%u, "

"dwFileOffsetH=%u, dwFileOffsetL=%u, dwNumberOfBytes=%u)\n",

hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh,

dwFileOffsetLow, dwNumberOfBytesToMap);

pThread = InternalGetCurrentThread();

palError = InternalMapViewOfFile(

pThread,

hFileMappingObject,

dwDesiredAccess,

dwFileOffsetHigh,

dwFileOffsetLow,

dwNumberOfBytesToMap,

&pvMappedBaseAddress

);

if (NO_ERROR != palError)

{

pThread->SetLastError(palError);

}

LOGEXIT( "MapViewOfFile returning %p.\n", pvMappedBaseAddress );

PERF_EXIT(MapViewOfFile);

return pvMappedBaseAddress;

}

LPVOID

PALAPI

MapViewOfFileEx(

IN HANDLE hFileMappingObject,

IN DWORD dwDesiredAccess,

IN DWORD dwFileOffsetHigh,

IN DWORD dwFileOffsetLow,

IN SIZE_T dwNumberOfBytesToMap,

IN LPVOID lpBaseAddress)

{

PAL_ERROR palError = NO_ERROR;

CPalThread *pThread = NULL;

LPVOID pvMappedBaseAddress = NULL;

PERF_ENTRY(MapViewOfFileEx);

ENTRY("MapViewOfFileEx(hFileMapping=%p, dwDesiredAccess=%u, "

"dwFileOffsetH=%u, dwFileOffsetL=%u, dwNumberOfBytes=%u, lpBaseAddress=%p)\n",

hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh,

dwFileOffsetLow, dwNumberOfBytesToMap, lpBaseAddress);