From a2fe398aeb1022b40233aa8234661fe4730461eb Mon Sep 17 00:00:00 2001 From: nattthebear Date: Fri, 25 Mar 2016 19:06:35 -0400 Subject: [PATCH] Refactoring MemoryBlock to use mapped fileviews, to allow for liveswapping. Posix codepath junked; it can return when there's someone to test it --- BizHawk.Emulation.Cores/ElfRunner.cs | 16 +- BizHawk.Emulation.Cores/MemoryBlock.cs | 292 ++++++++++++++++++------- 2 files changed, 223 insertions(+), 85 deletions(-) diff --git a/BizHawk.Emulation.Cores/ElfRunner.cs b/BizHawk.Emulation.Cores/ElfRunner.cs index a539133d4e..21305db42b 100644 --- a/BizHawk.Emulation.Cores/ElfRunner.cs +++ b/BizHawk.Emulation.Cores/ElfRunner.cs @@ -82,7 +82,7 @@ namespace BizHawk.Emulation.Cores try { _disposeList.Add(_base); - _base.Set(_base.Start, _base.Size, MemoryBlock.Protection.RW); + _base.Protect(_base.Start, _base.Size, MemoryBlock.Protection.RW); foreach (var seg in loadsegs) { @@ -93,14 +93,14 @@ namespace BizHawk.Emulation.Cores ProcessRelocations(); - _base.Set(_base.Start, _base.Size, MemoryBlock.Protection.R); + _base.Protect(_base.Start, _base.Size, MemoryBlock.Protection.R); foreach (var sec in _elf.Sections.Where(s => (s.Flags & SectionFlags.Allocatable) != 0)) { if ((sec.Flags & SectionFlags.Executable) != 0) - _base.Set((ulong)(sec.LoadAddress + _loadoffset), (ulong)sec.Size, MemoryBlock.Protection.RX); + _base.Protect((ulong)(sec.LoadAddress + _loadoffset), (ulong)sec.Size, MemoryBlock.Protection.RX); else if ((sec.Flags & SectionFlags.Writable) != 0) - _base.Set((ulong)(sec.LoadAddress + _loadoffset), (ulong)sec.Size, MemoryBlock.Protection.RW); + _base.Protect((ulong)(sec.LoadAddress + _loadoffset), (ulong)sec.Size, MemoryBlock.Protection.RW); } ulong end = _base.End; @@ -525,7 +525,7 @@ namespace BizHawk.Emulation.Cores throw new InvalidOperationException(string.Format("Failed to allocate {0} bytes from heap {1}", size, Name)); } ulong ret = Memory.Start + Used; - Memory.Set(ret, newused - Used, MemoryBlock.Protection.RW); + Memory.Protect(ret, newused - Used, MemoryBlock.Protection.RW); Used = newused; Console.WriteLine("Allocated {0} bytes on {1}", size, Name); return ret; @@ -540,7 +540,7 @@ namespace BizHawk.Emulation.Cores { if (!Sealed) { - Memory.Set(Memory.Start, Memory.Size, MemoryBlock.Protection.R); + Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.R); _hash = Hash(Memory.GetStream(Memory.Start, Used, false)); Sealed = true; } @@ -575,8 +575,8 @@ namespace BizHawk.Emulation.Cores throw new InvalidOperationException(string.Format("Heap {0} used {1} larger than available {2}", Name, used, Memory.Size)); if (!Sealed) { - Memory.Set(Memory.Start, Memory.Size, MemoryBlock.Protection.None); - Memory.Set(Memory.Start, used, MemoryBlock.Protection.RW); + Memory.Protect(Memory.Start, Memory.Size, MemoryBlock.Protection.None); + Memory.Protect(Memory.Start, used, MemoryBlock.Protection.RW); var ms = Memory.GetStream(Memory.Start, used, true); CopySome(br.BaseStream, ms, (long)used); Used = used; diff --git a/BizHawk.Emulation.Cores/MemoryBlock.cs b/BizHawk.Emulation.Cores/MemoryBlock.cs index ce69497fa2..4c9ab5dc0a 100644 --- a/BizHawk.Emulation.Cores/MemoryBlock.cs +++ b/BizHawk.Emulation.Cores/MemoryBlock.cs @@ -44,6 +44,55 @@ namespace BizHawk.Emulation.Cores public sealed class MemoryBlock : IDisposable { + /// + /// system page size + /// + public static int PageSize { get; private set;} + + /// + /// bitshift corresponding to PageSize + /// + private static readonly int PageShift; + /// + /// bitmask corresponding to PageSize + /// + private static readonly ulong PageMask; + + static MemoryBlock() + { + int p = PageSize = Environment.SystemPageSize; + while (p != 0) + { + p >>= 1; + PageShift++; + } + PageMask = (ulong)(PageSize - 1); + } + + /// + /// true if addr is aligned + /// + private static bool Aligned(ulong addr) + { + return (addr & PageMask) == 0; + } + + /// + /// align address down to previous page boundary + /// + private static ulong AlignDown(ulong addr) + { + return addr & ~PageMask; + } + + /// + /// align address up to next page boundary + /// + private static ulong AlignUp(ulong addr) + { + return ((addr - 1) | PageMask) + 1; + } + /// /// starting address of the memory block /// @@ -56,7 +105,40 @@ namespace BizHawk.Emulation.Cores /// ending address of the memory block; equal to start + size /// public ulong End { get; private set; } - public int PageSize { get { return Environment.SystemPageSize; } } + + /// + /// handle returned by CreateFileMapping + /// + private IntPtr _handle; + + /// + /// true if this is currently swapped in + /// + public bool Active { get; private set; } + + /// + /// stores last set memory protection value for each page + /// + private readonly Protection[] _pageData; + + /// + /// get a page index within the block + /// + private int GetPage(ulong addr) + { + if (addr < Start || addr >= End) + throw new ArgumentOutOfRangeException(); + + return (int)((addr - Start) >> PageShift); + } + + /// + /// get a start address for a page index within the block + /// + private ulong GetStartAddr(int page) + { + return ((ulong)page << PageShift) + Start; + } /// /// allocate size bytes at any address @@ -74,35 +156,62 @@ namespace BizHawk.Emulation.Cores /// public MemoryBlock(ulong start, ulong size) { -#if !MONO - Start = (ulong)Kernel32.VirtualAlloc(Z.UU(start), Z.UU(size), - Kernel32.AllocationType.RESERVE | Kernel32.AllocationType.COMMIT, - Kernel32.MemoryProtection.NOACCESS); - if (Start == 0) - { - throw new InvalidOperationException("VirtualAlloc() returned NULL"); - } - if (start != 0) - End = start + size; - else - End = Start + size; - Size = End - Start; -#else - Start = (ulong)LibC.mmap(ZC.U(start), ZC.U(size), 0, LibC.MapType.MAP_ANONYMOUS, -1, IntPtr.Zero); - if (Start == 0) - { - throw new InvalidOperationException("mmap() returned NULL"); - } - End = Start + size; - Size = End - Start; -#endif + if (!Aligned(start)) + throw new ArgumentOutOfRangeException(); + if (size == 0) + throw new ArgumentOutOfRangeException(); + size = AlignUp(size); + + _handle = Kernel32.CreateFileMapping(Kernel32.INVALID_HANDLE_VALUE, IntPtr.Zero, + Kernel32.FileMapProtection.PageExecuteReadWrite | Kernel32.FileMapProtection.SectionCommit, (uint)(size >> 32), (uint)size, null); + + if (_handle == IntPtr.Zero) + throw new InvalidOperationException("CreateFileMapping() returned NULL"); + Start = start; + End = start + size; + Size = size; + _pageData = new Protection[GetPage(End - 1) + 1]; + Activate(); } - public enum Protection + /// + /// activate the memory block, swapping it in at the specified address + /// + public void Activate() { - R, RW, RX, None + if (Active) + throw new InvalidOperationException("Already active"); + if (Kernel32.MapViewOfFileEx(_handle, Kernel32.FileMapAccessType.Read | Kernel32.FileMapAccessType.Write | Kernel32.FileMapAccessType.Execute, + 0, 0, Z.UU(Size), Z.US(Start)) != Z.US(Start)) + { + throw new InvalidOperationException("MapViewOfFileEx() returned NULL"); + } + ProtectAll(); + Active = true; } + /// + /// deactivate the memory block, removing it from RAM but leaving it immediately available to swap back in + /// + public void Deactivate() + { + if (!Active) + throw new InvalidOperationException("Not active"); + if (!Kernel32.UnmapViewOfFile(Z.US(Start))) + throw new InvalidOperationException("UnmapViewOfFile() returned NULL"); + } + + /// + /// Memory protection constant + /// + public enum Protection : byte + { + None, R, RW, RX + } + + /// + /// Get a stream that can be used to read or write from part of the block. Does not check for or change Protect()! + /// public Stream GetStream(ulong start, ulong length, bool writer) { if (start < Start) @@ -114,18 +223,8 @@ namespace BizHawk.Emulation.Cores return new MemoryViewStream(!writer, writer, (long)start, (long)length, this); } - public void Set(ulong start, ulong length, Protection prot) + private static Kernel32.MemoryProtection GetKernelMemoryProtectionValue(Protection prot) { - if (start < Start) - throw new ArgumentOutOfRangeException("start"); - - if (start + length > End) - throw new ArgumentOutOfRangeException("length"); - - if (length == 0) - return; - -#if !MONO Kernel32.MemoryProtection p; switch (prot) { @@ -135,24 +234,46 @@ namespace BizHawk.Emulation.Cores case Protection.RX: p = Kernel32.MemoryProtection.EXECUTE_READ; break; default: throw new ArgumentOutOfRangeException("prot"); } + return p; + } + + /// + /// restore all recorded protections + /// + private void ProtectAll() + { + int ps = 0; + for (int i = 0; i < _pageData.Length; i++) + { + if (i == _pageData.Length - 1 || _pageData[i] != _pageData[i + 1]) + { + var p = GetKernelMemoryProtectionValue(_pageData[i]); + ulong zstart = GetStartAddr(ps); + ulong zend = GetStartAddr(i + 1); + Kernel32.MemoryProtection old; + if (!Kernel32.VirtualProtect(Z.UU(zstart), Z.UU(zend - zstart), p, out old)) + throw new InvalidOperationException("VirtualProtect() returned FALSE!"); + } + } + } + + /// + /// set r/w/x protection on a portion of memory. rounded to encompassing pages + /// + public void Protect(ulong start, ulong length, Protection prot) + { + if (length == 0) + return; + int pstart = GetPage(start); + int pend = GetPage(start + length - 1); + + var p = GetKernelMemoryProtectionValue(prot); + for (int i = pstart; i <= pend; i++) + _pageData[i] = prot; // also store the value for later use + Kernel32.MemoryProtection old; if (!Kernel32.VirtualProtect(Z.UU(start), Z.UU(length), p, out old)) throw new InvalidOperationException("VirtualProtect() returned FALSE!"); -#else - LibC.ProtType p; - switch (prot) - { - case Protection.None: p = 0; break; - case Protection.R: p = LibC.ProtType.PROT_READ; break; - case Protection.RW: p = LibC.ProtType.PROT_READ | LibC.ProtType.PROT_WRITE; break; - case Protection.RX: p = LibC.ProtType.PROT_READ | LibC.ProtType.PROT_EXEC; break; - default: throw new ArgumentOutOfRangeException("prot"); - } - ulong end = (ulong)start + (ulong)length; - ulong newstart = (ulong)start & ~((ulong)Environment.SystemPageSize - 1); - if (LibC.mprotect((UIntPtr)newstart, (UIntPtr)(end - newstart), p) != 0) - throw new InvalidOperationException("mprotect() returned -1!"); -#endif } public void Dispose() @@ -163,14 +284,12 @@ namespace BizHawk.Emulation.Cores private void Dispose(bool disposing) { - if (Start != 0) + if (_handle != IntPtr.Zero) { -#if !MONO - Kernel32.VirtualFree(Z.UU(Start), UIntPtr.Zero, Kernel32.FreeType.RELEASE); -#else - LibC.munmap(ZC.U(Start), (UIntPtr)Size); -#endif - Start = 0; + if (Active) + Deactivate(); + Kernel32.CloseHandle(_handle); + _handle = IntPtr.Zero; } } @@ -273,8 +392,6 @@ namespace BizHawk.Emulation.Cores } } - -#if !MONO private static class Kernel32 { [DllImport("kernel32.dll", SetLastError = true)] @@ -323,31 +440,52 @@ namespace BizHawk.Emulation.Cores NOCACHE_Modifierflag = 0x200, WRITECOMBINE_Modifierflag = 0x400 } - } -#else - private static class LibC - { - [DllImport("libc.so")] - public static extern UIntPtr mmap(UIntPtr addr, UIntPtr length, ProtType prot, MapType flags, int fd, IntPtr offset); - [DllImport("libc.so")] - public static extern int munmap(UIntPtr addr, UIntPtr length); - [DllImport("libc.so")] - public static extern int mprotect(UIntPtr addr, UIntPtr length, ProtType prot); + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern IntPtr CreateFileMapping( + IntPtr hFile, + IntPtr lpFileMappingAttributes, + FileMapProtection flProtect, + uint dwMaximumSizeHigh, + uint dwMaximumSizeLow, + string lpName); [Flags] - public enum ProtType : int + public enum FileMapProtection : uint { - PROT_EXEC = 1, - PROT_WRITE = 2, - PROT_READ = 4 + PageReadonly = 0x02, + PageReadWrite = 0x04, + PageWriteCopy = 0x08, + PageExecuteRead = 0x20, + PageExecuteReadWrite = 0x40, + SectionCommit = 0x8000000, + SectionImage = 0x1000000, + SectionNoCache = 0x10000000, + SectionReserve = 0x4000000, } + [DllImport("kernel32.dll", SetLastError = true)] + public static extern bool CloseHandle(IntPtr hObject); + + [DllImport("kernel32.dll", SetLastError = true)] + public static extern bool UnmapViewOfFile(IntPtr lpBaseAddress); + + [DllImport("kernel32.dll")] + public static extern IntPtr MapViewOfFileEx(IntPtr hFileMappingObject, + FileMapAccessType dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, + UIntPtr dwNumberOfBytesToMap, IntPtr lpBaseAddress); + [Flags] - public enum MapType : int + public enum FileMapAccessType : uint { - MAP_ANONYMOUS = 2 + Copy = 0x01, + Write = 0x02, + Read = 0x04, + AllAccess = 0x08, + Execute = 0x20, } + + public static readonly IntPtr INVALID_HANDLE_VALUE = Z.US(0xffffffffffffffff); } -#endif } }