internal static MemoryMappedView CreateView(SafeMemoryMappedFileHandle memMappedFileHandle, MemoryMappedFileAccess access, long offset, long size)
{
ulong num3;
ulong num = (ulong)(offset % ((long)MemoryMappedFile.GetSystemPageAllocationGranularity()));
ulong num2 = ((ulong)offset) - num;
if (size != 0L)
{
num3 = ((ulong)size) + num;
}
else
{
num3 = 0L;
}
if ((IntPtr.Size == 4) && (num3 > 0xffffffffL))
{
throw new ArgumentOutOfRangeException("size", System.SR.GetString("ArgumentOutOfRange_CapacityLargerThanLogicalAddressSpaceNotAllowed"));
}
Microsoft.Win32.UnsafeNativeMethods.MEMORYSTATUSEX lpBuffer = new Microsoft.Win32.UnsafeNativeMethods.MEMORYSTATUSEX();
Microsoft.Win32.UnsafeNativeMethods.GlobalMemoryStatusEx(lpBuffer);
ulong ullTotalVirtual = lpBuffer.ullTotalVirtual;
if (num3 >= ullTotalVirtual)
{
throw new IOException(System.SR.GetString("IO_NotEnoughMemory"));
}
uint dwFileOffsetLow = (uint)(num2 & 0xffffffffL);
uint dwFileOffsetHigh = (uint)(num2 >> 0x20);
SafeMemoryMappedViewHandle address = Microsoft.Win32.UnsafeNativeMethods.MapViewOfFile(memMappedFileHandle, MemoryMappedFile.GetFileMapAccess(access), dwFileOffsetHigh, dwFileOffsetLow, new UIntPtr(num3));
if (address.IsInvalid)
{
System.IO.__Error.WinIOError(Marshal.GetLastWin32Error(), string.Empty);
}
Microsoft.Win32.UnsafeNativeMethods.MEMORY_BASIC_INFORMATION buffer = new Microsoft.Win32.UnsafeNativeMethods.MEMORY_BASIC_INFORMATION();
Microsoft.Win32.UnsafeNativeMethods.VirtualQuery(address, ref buffer, (IntPtr)Marshal.SizeOf(buffer));
ulong regionSize = (ulong)buffer.RegionSize;
if ((buffer.State & 0x2000) != 0)
{
Microsoft.Win32.UnsafeNativeMethods.VirtualAlloc(address, (UIntPtr)regionSize, 0x1000, MemoryMappedFile.GetPageAccess(access));
int errorCode = Marshal.GetLastWin32Error();
if (address.IsInvalid)
{
System.IO.__Error.WinIOError(errorCode, string.Empty);
}
}
if (size == 0L)
{
size = (long)(regionSize - num);
}
address.Initialize(((ulong)size) + num);
return(new MemoryMappedView(address, (long)num, size, access));
}
public GlobalMemoryMappedFile(string name, int size)
{
this.size = size;
var secAttribs = CreateSecAttribs();
try
{
memBuffer = NativeMethods.CreateFileMapping(
new IntPtr(-1),
ref secAttribs,
(int)NativeMethods.PageOptions.PAGE_READWRITE,
0,
size,
name);
if (memBuffer.IsInvalid)
{
//Console.WriteLine(memBuffer.DangerousGetHandle());
int lasterror = Marshal.GetLastWin32Error();
memBuffer.Dispose();
if (lasterror == 5)
{
throw new IOException("Access denied!");
}
memBuffer = NativeMethods.OpenFileMapping((int)NativeMethods.FileMapOptions.Full, false, name);
}
if (memBuffer.IsInvalid)
{
int lasterror = Marshal.GetLastWin32Error();
memBuffer.Dispose();
throw new Win32Exception(lasterror,
string.Format(CultureInfo.InvariantCulture, "Error creating shared memory. Errorcode is {0}",
lasterror));
}
accessor = NativeMethods.MapViewOfFile(memBuffer, (uint)NativeMethods.ViewAccess.FILE_MAP_ALL_ACCESS, 0,
0, (uint)size);
accessor.Initialize((uint)size);
if (accessor.IsInvalid)
{
accessor.Dispose();
memBuffer.Dispose();
int lasterror = Marshal.GetLastWin32Error();
throw new Win32Exception((int)lasterror,
string.Format(CultureInfo.InvariantCulture,
"Error creating shared memory view. Errorcode is {0}", lasterror));
}
}
finally
{
NativeMethods.SecHelper.Destroy(secAttribs);
}
}
private Win32MemoryMappedFile(FileStream fs, SafeMemoryMappedFileHandle handle, ulong size)
{
Contract.Requires(fs != null && handle != null && !handle.IsInvalid && !handle.IsClosed);
m_mapHandle = handle;
m_file = fs;
m_size = size;
// verify that it fits on 32 bit OS...
if (IntPtr.Size == 4 && size > uint.MaxValue)
{ // won't work with 32-bit pointers
throw new InvalidOperationException("Memory mapped file size is too big to be opened on a 32-bit system.");
}
// verifiy that it will fit in the virtual address space of the process
var totalVirtual = UnsafeNativeMethods.GetTotalVirtualAddressSpaceSize();
if (size > totalVirtual)
{
throw new InvalidOperationException("Memory mapped file size is too big to fit in the current process virtual address space");
}
SafeMemoryMappedViewHandle view = null;
byte *baseAddress = null;
try
{
view = UnsafeNativeMethods.MapViewOfFile(m_mapHandle, UnsafeNativeMethods.FileMapAccess.FileMapRead, 0, 0, new UIntPtr(size));
if (view.IsInvalid)
{
throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
}
view.Initialize(size);
m_viewHandle = view;
view.AcquirePointer(ref baseAddress);
m_baseAddress = baseAddress;
}
catch
{
if (baseAddress != null)
{
view.ReleasePointer();
}
if (view != null)
{
view.Dispose();
}
m_file = null;
m_viewHandle = null;
m_mapHandle = null;
m_baseAddress = null;
throw;
}
}
/// <summary>
/// Opens an existing minidump file on the specified path.
/// </summary>
/// <param name="path">The file to open.</param>
/// <returns></returns>
public static MiniDumpFile OpenExisting(string path)
{
MemoryMappedFile minidumpMappedFile = null;
SafeMemoryMappedViewHandle mappedFileView = null;
// MemoryMappedFile will close the FileStream when it gets Disposed.
FileStream fileStream = File.Open(path, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read);
try
{
minidumpMappedFile = MemoryMappedFile.CreateFromFile(fileStream, Path.GetFileName(path), 0, MemoryMappedFileAccess.Read, null, HandleInheritability.None, false);
mappedFileView = NativeMethods.MapViewOfFile(minidumpMappedFile.SafeMemoryMappedFileHandle, NativeMethods.FILE_MAP_READ, 0, 0, IntPtr.Zero);
if (mappedFileView.IsInvalid)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
MEMORY_BASIC_INFORMATION memoryInformation = default(MEMORY_BASIC_INFORMATION);
if (NativeMethods.VirtualQuery(mappedFileView, ref memoryInformation, (IntPtr)Marshal.SizeOf(memoryInformation)) == IntPtr.Zero)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
mappedFileView.Initialize((ulong)memoryInformation.RegionSize);
}
catch
{
// Cleanup whatever didn't work and rethrow
if ((minidumpMappedFile != null) && (!mappedFileView.IsInvalid))
{
minidumpMappedFile.Dispose();
}
if ((mappedFileView != null) && (!mappedFileView.IsInvalid))
{
mappedFileView.Dispose();
}
if (minidumpMappedFile == null)
{
fileStream?.Close();
}
throw;
}
return(new MiniDumpFile(minidumpMappedFile, mappedFileView));
}
public static unsafe MemoryMappedView CreateView(SafeMemoryMappedFileHandle memMappedFileHandle,
MemoryMappedFileAccess access, long offset, long size)
{
// MapViewOfFile can only create views that start at a multiple of the system memory allocation
// granularity. We decided to hide this restriction from the user by creating larger views than the
// user requested and hiding the parts that the user did not request. extraMemNeeded is the amount of
// extra memory we allocate before the start of the requested view. MapViewOfFile will also round the
// capacity of the view to the nearest multiple of the system page size. Once again, we hide this
// from the user by preventing them from writing to any memory that they did not request.
ulong nativeSize;
long extraMemNeeded, newOffset;
ValidateSizeAndOffset(
size, offset, GetSystemPageAllocationGranularity(),
out nativeSize, out extraMemNeeded, out newOffset);
// if request is >= than total virtual, then MapViewOfFile will fail with meaningless error message
// "the parameter is incorrect"; this provides better error message in advance
Interop.CheckForAvailableVirtualMemory(nativeSize);
// create the view
SafeMemoryMappedViewHandle viewHandle = Interop.MapViewOfFile(memMappedFileHandle,
(int)MemoryMappedFile.GetFileMapAccess(access), newOffset, new UIntPtr(nativeSize));
if (viewHandle.IsInvalid)
{
viewHandle.Dispose();
throw Win32Marshal.GetExceptionForLastWin32Error();
}
// Query the view for its size and allocation type
Interop.Kernel32.MEMORY_BASIC_INFORMATION viewInfo = new Interop.Kernel32.MEMORY_BASIC_INFORMATION();
Interop.Kernel32.VirtualQuery(viewHandle, ref viewInfo, (UIntPtr)Marshal.SizeOf(viewInfo));
ulong viewSize = (ulong)viewInfo.RegionSize;
// Allocate the pages if we were using the MemoryMappedFileOptions.DelayAllocatePages option
// OR check if the allocated view size is smaller than the expected native size
// If multiple overlapping views are created over the file mapping object, the pages in a given region
// could have different attributes(MEM_RESERVE OR MEM_COMMIT) as MapViewOfFile preserves coherence between
// views created on a mapping object backed by same file.
// In which case, the viewSize will be smaller than nativeSize required and viewState could be MEM_COMMIT
// but more pages may need to be committed in the region.
// This is because, VirtualQuery function(that internally invokes VirtualQueryEx function) returns the attributes
// and size of the region of pages with matching attributes starting from base address.
// VirtualQueryEx: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366907(v=vs.85).aspx
if (((viewInfo.State & Interop.Kernel32.MemOptions.MEM_RESERVE) != 0) || ((ulong)viewSize < (ulong)nativeSize))
{
IntPtr tempHandle = Interop.VirtualAlloc(
viewHandle, (UIntPtr)(nativeSize != MemoryMappedFile.DefaultSize ? nativeSize : viewSize),
Interop.Kernel32.MemOptions.MEM_COMMIT, MemoryMappedFile.GetPageAccess(access));
int lastError = Marshal.GetLastWin32Error();
if (viewHandle.IsInvalid)
{
viewHandle.Dispose();
throw Win32Marshal.GetExceptionForWin32Error(lastError);
}
// again query the view for its new size
viewInfo = new Interop.Kernel32.MEMORY_BASIC_INFORMATION();
Interop.Kernel32.VirtualQuery(viewHandle, ref viewInfo, (UIntPtr)Marshal.SizeOf(viewInfo));
viewSize = (ulong)viewInfo.RegionSize;
}
// if the user specified DefaultSize as the size, we need to get the actual size
if (size == MemoryMappedFile.DefaultSize)
{
size = (long)(viewSize - (ulong)extraMemNeeded);
}
else
{
Debug.Assert(viewSize >= (ulong)size, "viewSize < size");
}
viewHandle.Initialize((ulong)size + (ulong)extraMemNeeded);
return(new MemoryMappedView(viewHandle, extraMemNeeded, size, access));
}
public unsafe static MemoryMappedView CreateView(
SafeMemoryMappedFileHandle memMappedFileHandle, MemoryMappedFileAccess access,
long requestedOffset, long requestedSize)
{
if (requestedOffset > memMappedFileHandle._capacity)
{
throw new ArgumentOutOfRangeException("offset");
}
if (requestedSize > MaxProcessAddressSpace)
{
throw new IOException(SR.ArgumentOutOfRange_CapacityLargerThanLogicalAddressSpaceNotAllowed);
}
if (requestedOffset + requestedSize > memMappedFileHandle._capacity)
{
throw new UnauthorizedAccessException();
}
if (memMappedFileHandle.IsClosed)
{
throw new ObjectDisposedException(typeof(MemoryMappedFile).Name);
}
if (requestedSize == MemoryMappedFile.DefaultSize)
{
requestedSize = memMappedFileHandle._capacity - requestedOffset;
}
// mmap can only create views that start at a multiple of the page size. As on Windows,
// we hide this restriction form the user by creating larger views than the user requested and hiding the parts
// that the user did not request. extraMemNeeded is the amount of extra memory we allocate before the start of the
// requested view. (mmap may round up the actual length such that it is also page-aligned; we hide that by using
// the right size and not extending the size to be page-aligned.)
ulong nativeSize, extraMemNeeded, nativeOffset;
int pageSize = Interop.libc.sysconf(Interop.libc.SysConfNames._SC_PAGESIZE);
ValidateSizeAndOffset(
requestedSize, requestedOffset, pageSize,
out nativeSize, out extraMemNeeded, out nativeOffset);
if (nativeSize == 0)
{
nativeSize = (ulong)pageSize;
}
bool gotRefOnHandle = false;
try
{
// Determine whether to create the pages as private or as shared; the former is used for copy-on-write.
Interop.libc.MemoryMappedFlags flags =
(memMappedFileHandle._access == MemoryMappedFileAccess.CopyOnWrite || access == MemoryMappedFileAccess.CopyOnWrite) ?
Interop.libc.MemoryMappedFlags.MAP_PRIVATE :
Interop.libc.MemoryMappedFlags.MAP_SHARED;
// If we have a file handle, get the file descriptor from it. If the handle is null,
// we'll use an anonymous backing store for the map.
int fd;
if (memMappedFileHandle._fileHandle != null)
{
// Get the file descriptor from the SafeFileHandle
memMappedFileHandle._fileHandle.DangerousAddRef(ref gotRefOnHandle);
Debug.Assert(gotRefOnHandle);
fd = (int)memMappedFileHandle._fileHandle.DangerousGetHandle();
Debug.Assert(fd >= 0);
}
else
{
Debug.Assert(!gotRefOnHandle);
fd = -1;
flags |= Interop.libc.MemoryMappedFlags.MAP_ANONYMOUS;
}
// Nothing to do for options.DelayAllocatePages, since we're only creating the map
// with mmap when creating the view.
// Verify that the requested view permissions don't exceed the map's permissions
Interop.libc.MemoryMappedProtections viewProtForVerification = GetProtections(access, forVerification: true);
Interop.libc.MemoryMappedProtections mapProtForVerification = GetProtections(memMappedFileHandle._access, forVerification: true);
if ((viewProtForVerification & mapProtForVerification) != viewProtForVerification)
{
throw new UnauthorizedAccessException();
}
// Create the map
IntPtr addr = Interop.libc.mmap(
IntPtr.Zero, // don't specify an address; let the system choose one
(IntPtr)nativeSize, // specify the rounded-size we computed so as to page align; size + extraMemNeeded
GetProtections(access, forVerification: false), // viewProtections is strictly less than mapProtections, so use viewProtections
flags,
fd, // mmap adds a ref count to the fd, so there's no need to dup it.
(long)nativeOffset); // specify the rounded-offset we computed so as to page align; offset - extraMemNeeded
if ((long)addr < 0)
{
throw Interop.GetExceptionForIoErrno(Marshal.GetLastWin32Error());
}
// Based on the HandleInheritability, try to prevent the memory-mapped region
// from being inherited by a forked process
if (memMappedFileHandle._inheritability == HandleInheritability.None)
{
int adviseResult = Interop.libc.madvise(addr, (IntPtr)nativeSize, Interop.libc.MemoryMappedAdvice.MADV_DONTFORK);
Debug.Assert(adviseResult == 0); // In release, ignore failures from advise; it's just a hint, anyway.
}
// Create and return the view handle
var viewHandle = new SafeMemoryMappedViewHandle(addr, ownsHandle: true);
viewHandle.Initialize(nativeSize);
return(new MemoryMappedView(
viewHandle,
(long)extraMemNeeded, // the view points to offset - extraMemNeeded, so we need to shift back by extraMemNeeded
requestedSize, // only allow access to the actual size requested
access));
}
finally
{
if (gotRefOnHandle)
{
memMappedFileHandle._fileHandle.DangerousRelease();
}
}
}
public static MemoryMappedView CreateView(
SafeMemoryMappedFileHandle memMappedFileHandle, MemoryMappedFileAccess access,
long requestedOffset, long requestedSize)
{
if (requestedOffset > memMappedFileHandle._capacity)
{
throw new ArgumentOutOfRangeException("offset");
}
if (requestedSize > MaxProcessAddressSpace)
{
throw new IOException(SR.ArgumentOutOfRange_CapacityLargerThanLogicalAddressSpaceNotAllowed);
}
if (requestedOffset + requestedSize > memMappedFileHandle._capacity)
{
throw new UnauthorizedAccessException();
}
if (memMappedFileHandle.IsClosed)
{
throw new ObjectDisposedException(nameof(MemoryMappedFile));
}
if (requestedSize == MemoryMappedFile.DefaultSize)
{
requestedSize = memMappedFileHandle._capacity - requestedOffset;
}
// mmap can only create views that start at a multiple of the page size. As on Windows,
// we hide this restriction form the user by creating larger views than the user requested and hiding the parts
// that the user did not request. extraMemNeeded is the amount of extra memory we allocate before the start of the
// requested view. (mmap may round up the actual length such that it is also page-aligned; we hide that by using
// the right size and not extending the size to be page-aligned.)
ulong nativeSize;
long extraMemNeeded, nativeOffset;
long pageSize = Interop.Sys.SysConf(Interop.Sys.SysConfName._SC_PAGESIZE);
Debug.Assert(pageSize > 0);
ValidateSizeAndOffset(
requestedSize, requestedOffset, pageSize,
out nativeSize, out extraMemNeeded, out nativeOffset);
// Determine whether to create the pages as private or as shared; the former is used for copy-on-write.
Interop.Sys.MemoryMappedFlags flags =
(memMappedFileHandle._access == MemoryMappedFileAccess.CopyOnWrite || access == MemoryMappedFileAccess.CopyOnWrite) ?
Interop.Sys.MemoryMappedFlags.MAP_PRIVATE :
Interop.Sys.MemoryMappedFlags.MAP_SHARED;
// If we have a file handle, get the file descriptor from it. If the handle is null,
// we'll use an anonymous backing store for the map.
SafeFileHandle fd;
if (memMappedFileHandle._fileStream != null)
{
// Get the file descriptor from the SafeFileHandle
fd = memMappedFileHandle._fileStream.SafeFileHandle;
Debug.Assert(!fd.IsInvalid);
}
else
{
fd = new SafeFileHandle(new IntPtr(-1), false);
flags |= Interop.Sys.MemoryMappedFlags.MAP_ANONYMOUS;
}
// Nothing to do for options.DelayAllocatePages, since we're only creating the map
// with mmap when creating the view.
// Verify that the requested view permissions don't exceed the map's permissions
Interop.Sys.MemoryMappedProtections viewProtForVerification = GetProtections(access, forVerification: true);
Interop.Sys.MemoryMappedProtections mapProtForVerification = GetProtections(memMappedFileHandle._access, forVerification: true);
if ((viewProtForVerification & mapProtForVerification) != viewProtForVerification)
{
throw new UnauthorizedAccessException();
}
// viewProtections is strictly less than mapProtections, so use viewProtections for actually creating the map.
Interop.Sys.MemoryMappedProtections viewProtForCreation = GetProtections(access, forVerification: false);
// Create the map
IntPtr addr = IntPtr.Zero;
if (nativeSize > 0)
{
addr = Interop.Sys.MMap(
IntPtr.Zero, // don't specify an address; let the system choose one
nativeSize, // specify the rounded-size we computed so as to page align; size + extraMemNeeded
viewProtForCreation,
flags,
fd, // mmap adds a ref count to the fd, so there's no need to dup it.
nativeOffset); // specify the rounded-offset we computed so as to page align; offset - extraMemNeeded
}
else
{
// There are some corner cases where the .NET API allows the requested size to be zero, e.g. the caller is
// creating a map at the end of the capacity. We can't pass 0 to mmap, as that'll fail with EINVAL, nor can
// we create a map that extends beyond the end of the underlying file, as that'll fail on some platforms at the
// time of the map's creation. Instead, since there's no data to be read/written, it doesn't actually matter
// what backs the view, so we just create an anonymous mapping.
addr = Interop.Sys.MMap(
IntPtr.Zero,
1, // any length that's greater than zero will suffice
viewProtForCreation,
flags | Interop.Sys.MemoryMappedFlags.MAP_ANONYMOUS,
new SafeFileHandle(new IntPtr(-1), false), // ignore the actual fd even if there was one
0);
requestedSize = 0;
extraMemNeeded = 0;
}
if (addr == IntPtr.Zero) // note that shim uses null pointer, not non-null MAP_FAILED sentinel
{
throw Interop.GetExceptionForIoErrno(Interop.Sys.GetLastErrorInfo());
}
// Based on the HandleInheritability, try to prevent the memory-mapped region
// from being inherited by a forked process
if (memMappedFileHandle._inheritability == HandleInheritability.None)
{
DisableForkingIfPossible(addr, nativeSize);
}
// Create and return the view handle
var viewHandle = new SafeMemoryMappedViewHandle(addr, ownsHandle: true);
viewHandle.Initialize((ulong)nativeSize);
return(new MemoryMappedView(
viewHandle,
extraMemNeeded, // the view points to offset - extraMemNeeded, so we need to shift back by extraMemNeeded
requestedSize, // only allow access to the actual size requested
access));
}
public unsafe static MemoryMappedView CreateView(SafeMemoryMappedFileHandle memMappedFileHandle,
MemoryMappedFileAccess access, Int64 offset, Int64 size)
{
// MapViewOfFile can only create views that start at a multiple of the system memory allocation
// granularity. We decided to hide this restriction form the user by creating larger views than the
// user requested and hiding the parts that the user did not request. extraMemNeeded is the amount of
// extra memory we allocate before the start of the requested view. MapViewOfFile will also round the
// capacity of the view to the nearest multiple of the system page size. Once again, we hide this
// from the user by preventing them from writing to any memory that they did not request.
ulong extraMemNeeded = (ulong)offset % (ulong)GetSystemPageAllocationGranularity();
// newOffset takes into account the fact that we have some extra memory allocated before the requested view
ulong newOffset = (ulong)offset - extraMemNeeded;
Debug.Assert(newOffset >= 0, "newOffset = (offset - extraMemNeeded) < 0");
// determine size to pass to MapViewOfFile
ulong nativeSize = (size != MemoryMappedFile.DefaultSize) ?
(ulong)size + (ulong)extraMemNeeded :
0;
if (IntPtr.Size == 4 && nativeSize > UInt32.MaxValue)
{
throw new ArgumentOutOfRangeException("size", SR.ArgumentOutOfRange_CapacityLargerThanLogicalAddressSpaceNotAllowed);
}
// if request is >= than total virtual, then MapViewOfFile will fail with meaningless error message
// "the parameter is incorrect"; this provides better error message in advance
Interop.MEMORYSTATUSEX memStatus;
memStatus.dwLength = (uint)sizeof(Interop.MEMORYSTATUSEX);
Interop.mincore.GlobalMemoryStatusEx(out memStatus);
ulong totalVirtual = memStatus.ullTotalVirtual;
if (nativeSize >= totalVirtual)
{
throw new IOException(SR.IO_NotEnoughMemory);
}
// split the Int64 into two ints
int offsetLow = unchecked ((int)(newOffset & 0x00000000FFFFFFFFL));
int offsetHigh = unchecked ((int)(newOffset >> 32));
// create the view
SafeMemoryMappedViewHandle viewHandle = Interop.mincore.MapViewOfFile(memMappedFileHandle,
(int)MemoryMappedFile.GetFileMapAccess(access), offsetHigh, offsetLow, new UIntPtr(nativeSize));
if (viewHandle.IsInvalid)
{
throw Win32Marshal.GetExceptionForLastWin32Error();
}
// Query the view for its size and allocation type
Interop.MEMORY_BASIC_INFORMATION viewInfo = new Interop.MEMORY_BASIC_INFORMATION();
Interop.mincore.VirtualQuery(viewHandle, ref viewInfo, (UIntPtr)Marshal.SizeOf(viewInfo));
ulong viewSize = (ulong)viewInfo.RegionSize;
// Allocate the pages if we were using the MemoryMappedFileOptions.DelayAllocatePages option
// OR check if the allocated view size is smaller than the expected native size
// If multiple overlapping views are created over the file mapping object, the pages in a given region
// could have different attributes(MEM_RESERVE OR MEM_COMMIT) as MapViewOfFile preserves coherence between
// views created on a mapping object backed by same file.
// In which case, the viewSize will be smaller than nativeSize required and viewState could be MEM_COMMIT
// but more pages may need to be committed in the region.
// This is because, VirtualQuery function(that internally invokes VirtualQueryEx function) returns the attributes
// and size of the region of pages with matching attributes starting from base address.
// VirtualQueryEx: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366907(v=vs.85).aspx
if (((viewInfo.State & Interop.MEM_RESERVE) != 0) || (viewSize < nativeSize))
{
IntPtr tempHandle = Interop.mincore.VirtualAlloc(viewHandle, (UIntPtr)nativeSize, Interop.MEM_COMMIT,
MemoryMappedFile.GetPageAccess(access));
int lastError = Marshal.GetLastWin32Error();
if (viewHandle.IsInvalid)
{
throw Win32Marshal.GetExceptionForWin32Error(lastError);
}
// again query the view for its new size
viewInfo = new Interop.MEMORY_BASIC_INFORMATION();
Interop.mincore.VirtualQuery(viewHandle, ref viewInfo, (UIntPtr)Marshal.SizeOf(viewInfo));
viewSize = (ulong)viewInfo.RegionSize;
}
// if the user specified DefaultSize as the size, we need to get the actual size
if (size == MemoryMappedFile.DefaultSize)
{
size = (Int64)(viewSize - extraMemNeeded);
}
else
{
Debug.Assert(viewSize >= (ulong)size, "viewSize < size");
}
viewHandle.Initialize((ulong)size + extraMemNeeded);
return(new MemoryMappedView(viewHandle, (long)extraMemNeeded, size, access));
}
internal unsafe static MemoryMappedView CreateView(SafeMemoryMappedFileHandle memMappedFileHandle,
MemoryMappedFileAccess access, Int64 offset, Int64 size)
{
// MapViewOfFile can only create views that start at a multiple of the system memory allocation
// granularity. We decided to hide this restriction form the user by creating larger views than the
// user requested and hiding the parts that the user did not request. extraMemNeeded is the amount of
// extra memory we allocate before the start of the requested view. MapViewOfFile will also round the
// capacity of the view to the nearest multiple of the system page size. Once again, we hide this
// from the user by preventing them from writing to any memory that they did not request.
ulong extraMemNeeded = (ulong)offset % (ulong)MemoryMappedFile.GetSystemPageAllocationGranularity();
// newOffset takes into account the fact that we have some extra memory allocated before the requested view
ulong newOffset = (ulong)offset - extraMemNeeded;
Debug.Assert(newOffset >= 0, "newOffset = (offset - extraMemNeeded) < 0");
// determine size to pass to MapViewOfFile
ulong nativeSize;
if (size != MemoryMappedFile.DefaultSize)
{
nativeSize = (ulong)size + (ulong)extraMemNeeded;
}
else
{
nativeSize = 0;
}
if (IntPtr.Size == 4 && nativeSize > UInt32.MaxValue)
{
throw new ArgumentOutOfRangeException("size", SR.GetString(SR.ArgumentOutOfRange_CapacityLargerThanLogicalAddressSpaceNotAllowed));
}
// if request is >= than total virtual, then MapViewOfFile will fail with meaningless error message
// "the parameter is incorrect"; this provides better error message in advance
UnsafeNativeMethods.MEMORYSTATUSEX memStatus = new UnsafeNativeMethods.MEMORYSTATUSEX();
bool result = UnsafeNativeMethods.GlobalMemoryStatusEx(memStatus);
ulong totalVirtual = memStatus.ullTotalVirtual;
if (nativeSize >= totalVirtual)
{
throw new IOException(SR.GetString(SR.IO_NotEnoughMemory));
}
// split the Int64 into two ints
uint offsetLow = (uint)(newOffset & 0x00000000FFFFFFFFL);
uint offsetHigh = (uint)(newOffset >> 32);
// create the view
SafeMemoryMappedViewHandle viewHandle = UnsafeNativeMethods.MapViewOfFile(memMappedFileHandle,
MemoryMappedFile.GetFileMapAccess(access), offsetHigh, offsetLow, new UIntPtr(nativeSize));
if (viewHandle.IsInvalid)
{
__Error.WinIOError(Marshal.GetLastWin32Error(), String.Empty);
}
// Query the view for its size and allocation type
UnsafeNativeMethods.MEMORY_BASIC_INFORMATION viewInfo = new UnsafeNativeMethods.MEMORY_BASIC_INFORMATION();
UnsafeNativeMethods.VirtualQuery(viewHandle, ref viewInfo, (IntPtr)Marshal.SizeOf(viewInfo));
ulong viewSize = (ulong)viewInfo.RegionSize;
// allocate the pages if we were using the MemoryMappedFileOptions.DelayAllocatePages option
if ((viewInfo.State & UnsafeNativeMethods.MEM_RESERVE) != 0)
{
IntPtr tempHandle = UnsafeNativeMethods.VirtualAlloc(viewHandle, (UIntPtr)viewSize, UnsafeNativeMethods.MEM_COMMIT,
MemoryMappedFile.GetPageAccess(access));
int lastError = Marshal.GetLastWin32Error();
if (viewHandle.IsInvalid)
{
__Error.WinIOError(lastError, String.Empty);
}
}
// if the user specified DefaultSize as the size, we need to get the actual size
if (size == MemoryMappedFile.DefaultSize)
{
size = (Int64)(viewSize - extraMemNeeded);
}
else
{
Debug.Assert(viewSize >= (ulong)size, "viewSize < size");
}
viewHandle.Initialize((ulong)size + extraMemNeeded);
MemoryMappedView mmv = new MemoryMappedView(viewHandle, (long)extraMemNeeded, size, access);
return(mmv);
}