/// <summary> /// Creates a new instance of the host mapped memory manager. /// </summary> /// <param name="backingMemory">Physical backing memory where virtual memory will be mapped to</param> /// <param name="addressSpaceSize">Size of the address space</param> /// <param name="unsafeMode">True if unmanaged access should not be masked (unsafe), false otherwise.</param> /// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param> public MemoryManagerHostMapped(MemoryBlock backingMemory, ulong addressSpaceSize, bool unsafeMode, InvalidAccessHandler invalidAccessHandler = null) { _backingMemory = backingMemory; _pageTable = new PageTable <ulong>(); _invalidAccessHandler = invalidAccessHandler; _unsafeMode = unsafeMode; _addressSpaceSize = addressSpaceSize; ulong asSize = PageSize; int asBits = PageBits; while (asSize < addressSpaceSize) { asSize <<= 1; asBits++; } AddressSpaceBits = asBits; _pageBitmap = new ulong[1 << (AddressSpaceBits - (PageBits + PageToPteShift))]; MemoryAllocationFlags asFlags = MemoryAllocationFlags.Reserve | MemoryAllocationFlags.ViewCompatible; _addressSpace = new MemoryBlock(asSize, asFlags); _addressSpaceMirror = new MemoryBlock(asSize, asFlags | MemoryAllocationFlags.ForceWindows4KBViewMapping); Tracking = new MemoryTracking(this, PageSize, invalidAccessHandler); _memoryEh = new MemoryEhMeilleure(_addressSpace, Tracking); }
public MemoryEhMeilleure(MemoryBlock addressSpace, MemoryBlock addressSpaceMirror, MemoryTracking tracking) { _tracking = tracking; _baseAddress = (ulong)addressSpace.Pointer; ulong endAddress = _baseAddress + addressSpace.Size; _trackingEvent = new TrackingEventDelegate(tracking.VirtualMemoryEvent); bool added = NativeSignalHandler.AddTrackedRegion((nuint)_baseAddress, (nuint)endAddress, Marshal.GetFunctionPointerForDelegate(_trackingEvent)); if (!added) { throw new InvalidOperationException("Number of allowed tracked regions exceeded."); } if (OperatingSystem.IsWindows()) { // Add a tracking event with no signal handler for the mirror on Windows. // The native handler has its own code to check for the partial overlap race when regions are protected by accident, // and when there is no signal handler present. _mirrorAddress = (ulong)addressSpaceMirror.Pointer; ulong endAddressMirror = _mirrorAddress + addressSpace.Size; bool addedMirror = NativeSignalHandler.AddTrackedRegion((nuint)_mirrorAddress, (nuint)endAddressMirror, IntPtr.Zero); if (!addedMirror) { throw new InvalidOperationException("Number of allowed tracked regions exceeded."); } } }
private (MemoryBlock virt, MemoryBlock mirror, MemoryEhMeilleure exceptionHandler) GetVirtual(ulong asSize) { MemoryAllocationFlags asFlags = MemoryAllocationFlags.Reserve | MemoryAllocationFlags.ViewCompatible; var addressSpace = new MemoryBlock(asSize, asFlags); var addressSpaceMirror = new MemoryBlock(asSize, asFlags); var tracking = new MemoryTracking(new MockVirtualMemoryManager(asSize, 0x1000), 0x1000); var exceptionHandler = new MemoryEhMeilleure(addressSpace, addressSpaceMirror, tracking); return(addressSpace, addressSpaceMirror, exceptionHandler); }
public MemoryEhMeilleure(MemoryBlock addressSpace, MemoryTracking tracking) { _addressSpace = addressSpace; _tracking = tracking; _baseAddress = (ulong)_addressSpace.Pointer; ulong endAddress = _baseAddress + addressSpace.Size; _trackingEvent = new TrackingEventDelegate(tracking.VirtualMemoryEvent); bool added = NativeSignalHandler.AddTrackedRegion((nuint)_baseAddress, (nuint)endAddress, Marshal.GetFunctionPointerForDelegate(_trackingEvent)); if (!added) { throw new InvalidOperationException("Number of allowed tracked regions exceeded."); } }
/// <summary> /// Creates a new instance of the memory manager. /// </summary> /// <param name="addressSpaceSize">Size of the address space</param> /// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param> public MemoryManager(ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler = null) { _invalidAccessHandler = invalidAccessHandler; ulong asSize = PageSize; int asBits = PageBits; while (asSize < addressSpaceSize) { asSize <<= 1; asBits++; } AddressSpaceBits = asBits; _addressSpaceSize = asSize; _pageTable = new MemoryBlock((asSize / PageSize) * PteSize); Tracking = new MemoryTracking(this, PageSize); }
/// <summary> /// Creates a new instance of the memory manager. /// </summary> /// <param name="addressSpaceSize">Size of the address space</param> /// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param> public MemoryManager(ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler = null) { _invalidAccessHandler = invalidAccessHandler; ulong asSize = PageSize; int asBits = PageBits; while (asSize < addressSpaceSize) { asSize <<= 1; asBits++; } AddressSpaceBits = asBits; _addressSpaceSize = asSize; _pageTable = new MemoryBlock((asSize / PageSize) * PteSize); Tracking = new MemoryTracking(this, PageSize); Tracking.EnablePhysicalProtection = false; // Disabled for now, as protection is done in software. }
/// <summary> /// Creates a new instance of the host mapped memory manager. /// </summary> /// <param name="addressSpaceSize">Size of the address space</param> /// <param name="invalidAccessHandler">Optional function to handle invalid memory accesses</param> public MemoryManagerHostMapped(ulong addressSpaceSize, InvalidAccessHandler invalidAccessHandler = null) { _invalidAccessHandler = invalidAccessHandler; _addressSpaceSize = addressSpaceSize; ulong asSize = PageSize; int asBits = PageBits; while (asSize < addressSpaceSize) { asSize <<= 1; asBits++; } AddressSpaceBits = asBits; _pageTable = new ulong[1 << (AddressSpaceBits - (PageBits + PageToPteShift))]; _addressSpace = new MemoryBlock(asSize, MemoryAllocationFlags.Reserve | MemoryAllocationFlags.Mirrorable); _addressSpaceMirror = _addressSpace.CreateMirror(); Tracking = new MemoryTracking(this, PageSize, invalidAccessHandler); _memoryEh = new MemoryEhMeilleure(_addressSpace, Tracking); }
public void Setup() { _memoryBlock = new MemoryBlock(MemorySize); _memoryManager = new MockVirtualMemoryManager(MemorySize, PageSize); _tracking = new MemoryTracking(_memoryManager, _memoryBlock, PageSize); }