ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Clean up and remove a lot of no longer used memory block stuff 

All of the cool and quirky stuff it did was solely to support waterbox, which has its own native impl of this now.  So now it just lets you allocate memory and change protection on it.  Boring.  Note that the slot based callback system in waterbox gives constant function pointer addresses inside the box, so it doesn't matter where exactly CallingConventionAdapter is allocated.
This commit is contained in:
nattthebear 2020-08-13 19:41:52 -04:00
parent ad07eb8574
commit 5d3b85ab9f
5 changed files with 48 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/BizHawk.BizInvoke/CallingConventionAdapter.cs
View File

@ -277,8 +277,7 @@ namespace BizHawk.BizInvoke
public MsHostSysVGuest()
{
int size = 4 * 1024 * 1024;
_memory = MemoryBlock.Create(0x36a00000000, (ulong)size);
_memory.Activate();
_memory = new MemoryBlock((ulong)size);
_refs = new WeakReference[size / BlockSize];
}

24
src/BizHawk.BizInvoke/IMemoryBlockPal.cs
View File

@ -7,30 +7,10 @@ namespace BizHawk.BizInvoke
/// </summary>
public interface IMemoryBlockPal : IDisposable
{
public ulong Start { get; }
/// <summary>
/// Map in the memory area at the predetermined address. uncommitted space should be unreadable.
/// For all other space, there is no requirement on initial protection value;
/// correct protections will be applied via Protect() immediately after this call.
/// There is no assumption for the values of WriteStatus either, which will be supplied immediately
/// after this call
/// </summary>
void Activate();
/// <summary>
/// Unmap the memory area from memory. All data needs to be preserved for next load.
/// </summary>
void Deactivate();
/// <summary>
/// Change protection on [start, start + size), guaranteed to be page aligned and in the committed area.
/// Will only be called when active. Will not be called with RW_Invisible, which is a front end artifact.
/// Change protection on [start, start + size), guaranteed to be page aligned and in the allocated area
/// </summary>
void Protect(ulong start, ulong size, MemoryBlock.Protection prot);
/// <summary>
/// mark [Block.Start, Block.Start + length) as committed. Always greater than a previous length;
/// no uncommitting is allowed.
/// Will only be called when active.
/// there is no requirement on initial protection value of any committed memory (newly or otherwise)
/// after this call; protections will be applied via Protect() immediately after this call.
/// </summary>
void Commit(ulong length);
}
}

114
src/BizHawk.BizInvoke/MemoryBlock.cs
View File

@ -10,35 +10,23 @@ namespace BizHawk.BizInvoke
{
/// <summary>allocate <paramref name="size"/> bytes starting at a particular address <paramref name="start"/></summary>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> is not aligned or <paramref name="size"/> is <c>0</c></exception>
public MemoryBlock(ulong start, ulong size)
public MemoryBlock(ulong size)
{
if (!WaterboxUtils.Aligned(start))
throw new ArgumentOutOfRangeException(nameof(start), start, "start address must be aligned");
if (!WaterboxUtils.Aligned(size))
throw new ArgumentOutOfRangeException(nameof(size), size, "size must be aligned");
if (size == 0)
throw new ArgumentOutOfRangeException(nameof(size), size, "cannot create 0-length block");
if (start == 0)
throw new NotImplementedException("Start == 0 doesn't work right now, not really");
Start = start;
Size = WaterboxUtils.AlignUp(size);
EndExclusive = Start + Size;
_pageData = (Protection[])(object)new byte[GetPage(EndExclusive - 1) + 1];
_pal = OSTailoredCode.IsUnixHost
? (IMemoryBlockPal)new MemoryBlockLinuxPal(Start, Size)
: new MemoryBlockWindowsPal(Start, Size);
? (IMemoryBlockPal)new MemoryBlockLinuxPal(Size)
: new MemoryBlockWindowsPal(Size);
Start = _pal.Start;
EndExclusive = Start + Size;
}
private IMemoryBlockPal _pal;
/// <summary>
/// Size that has been committed to actual underlying RAM. Never shrinks. Private because
/// it should be transparent to the caller. ALWAYS ALIGNED.
/// </summary>
private ulong CommittedSize;
/// <summary>stores last set memory protection value for each page</summary>
private Protection[] _pageData;
/// <summary>
/// end address of the memory block (not part of the block; class invariant: equal to <see cref="Start"/> + <see cref="Size"/>)
/// </summary>
@ -50,26 +38,6 @@ namespace BizHawk.BizInvoke
/// <summary>starting address of the memory block</summary>
public readonly ulong Start;
/// <summary>true if this is currently swapped in</summary>
public bool Active { get; private set; }
/// <summary>get a page index within the block</summary>
private int GetPage(ulong addr)
{
if (addr < Start || addr >= EndExclusive)
throw new ArgumentOutOfRangeException(nameof(addr), addr, "invalid address");
return (int) ((addr - Start) >> WaterboxUtils.PageShift);
}
/// <summary>get a start address for a page index within the block</summary>
private ulong GetStartAddr(int page) => ((ulong) page << WaterboxUtils.PageShift) + Start;
private void EnsureActive()
{
if (!Active)
throw new InvalidOperationException("MemoryBlock is not currently active");
}
/// <summary>
/// Get a stream that can be used to read or write from part of the block. Does not check for or change <see cref="Protect"/>!
/// </summary>
@ -86,33 +54,10 @@ namespace BizHawk.BizInvoke
return new MemoryViewStream(!writer, writer, (long)start, (long)length);
}
/// <summary>activate the memory block, swapping it in at the pre-specified address</summary>
/// <exception cref="InvalidOperationException"><see cref="MemoryBlock.Active"/> is <see langword="true"/> or failed to map file view</exception>
public void Activate()
{
if (Active)
throw new InvalidOperationException("Already active");
_pal.Activate();
ProtectAll();
Active = true;
}
/// <summary>deactivate the memory block, removing it from RAM but leaving it immediately available to swap back in</summary>
/// <exception cref="InvalidOperationException">
/// <see cref="MemoryBlock.Active"/> is <see langword="false"/> or failed to unmap file view
/// </exception>
public void Deactivate()
{
EnsureActive();
_pal.Deactivate();
Active = false;
}
/// <summary>set r/w/x protection on a portion of memory. rounded to encompassing pages</summary>
/// <exception cref="InvalidOperationException">failed to protect memory</exception>
public void Protect(ulong start, ulong length, Protection prot)
{
EnsureActive();
if (length == 0)
return;
@ -122,44 +67,7 @@ namespace BizHawk.BizInvoke
var computedEnd = WaterboxUtils.AlignUp(start + length);
var computedLength = computedEnd - computedStart;
// potentially commit more memory
var minNewCommittedSize = computedEnd - Start;
if (minNewCommittedSize > CommittedSize)
{
CommittedSize = minNewCommittedSize;
// Since Commit() was called, we have to do a full ProtectAll -- remember that when refactoring
_pal.Commit(CommittedSize);
}
int pstart = GetPage(start);
int pend = GetPage(start + length - 1);
for (int i = pstart; i <= pend; i++)
{
_pageData[i] = prot;
}
// TODO: restore the previous behavior where we would only reprotect a partial range
ProtectAll();
}
/// <summary>restore all recorded protections</summary>
private void ProtectAll()
{
if (CommittedSize == 0)
return;
int ps = 0;
int pageLimit = (int)(CommittedSize >> WaterboxUtils.PageShift);
for (int i = 0; i < pageLimit; i++)
{
if (i == pageLimit - 1 || _pageData[i] != _pageData[i + 1])
{
ulong zstart = GetStartAddr(ps);
ulong zend = GetStartAddr(i + 1);
var prot = _pageData[i];
_pal.Protect(zstart, zend - zstart, prot);
ps = i + 1;
}
}
_pal.Protect(computedStart, computedLength, prot);
}
public void Dispose()
@ -171,12 +79,6 @@ namespace BizHawk.BizInvoke
}
}
/// <summary>allocate <paramref name="size"/> bytes starting at a particular address <paramref name="start"/></summary>
public static MemoryBlock Create(ulong start, ulong size) => new MemoryBlock(start, size);
/// <summary>allocate <paramref name="size"/> bytes at any address</summary>
public static MemoryBlock Create(ulong size) => Create(0, size);
/// <summary>Memory protection constant</summary>
public enum Protection : byte
{

90
src/BizHawk.BizInvoke/MemoryBlockLinuxPal.cs
View File

@ -7,52 +7,32 @@ namespace BizHawk.BizInvoke
{
internal sealed unsafe class MemoryBlockLinuxPal : IMemoryBlockPal
{
/*
Differences compared with MemoryBlockWindowsPal:
1) Commit is handled by only mapping up to the commit size, and then expanding commit is handled by unmap + truncate + remap.
So all unmanaged structures (including LinGuard) are always looking at the committed size, not total size.
2) Because of sigaltstack, RW_Stack is not needed and is made to behave the same as regular write guarding.
*/
/// <summary>handle returned by <see cref="memfd_create"/></summary>
private int _fd = -1;
private ulong _start;
private ulong _size;
private ulong _committedSize;
private bool _active;
public ulong Start { get; }
private readonly ulong _size;
private bool _disposed;
/// <summary>
/// Reserve bytes to later be swapped in, but do not map them
/// Map some bytes
/// </summary>
/// <param name="start">eventual mapped address</param>
/// <param name="size"></param>
/// <exception cref="InvalidOperationException">
/// failed to get file descriptor
/// failed to mmap
/// </exception>
public MemoryBlockLinuxPal(ulong start, ulong size)
public MemoryBlockLinuxPal(ulong size)
{
_start = start;
var ptr = (ulong)mmap(IntPtr.Zero, Z.UU(size), MemoryProtection.None, 0x22 /* MAP_PRIVATE | MAP_ANON */, -1, IntPtr.Zero);
if (ptr == ulong.MaxValue)
throw new InvalidOperationException($"{nameof(mmap)}() failed with error {Marshal.GetLastWin32Error()}");
_size = size;
_fd = memfd_create("MemoryBlockUnix", 1 /*MFD_CLOEXEC*/);
if (_fd == -1)
throw new InvalidOperationException($"{nameof(memfd_create)}() failed with error {Marshal.GetLastWin32Error()}");
Start = ptr;
}
public void Dispose()
{
if (_fd == -1)
if (_disposed)
return;
if (_active)
{
try
{
Deactivate();
}
catch
{}
}
close(_fd);
_fd = -1;
munmap(Z.US(Start), Z.UU(_size));
_disposed = true;
GC.SuppressFinalize(this);
}
@ -61,50 +41,6 @@ namespace BizHawk.BizInvoke
Dispose();
}
public void Activate()
{
if (_committedSize > 0)
{
var ptr = mmap(Z.US(_start), Z.UU(_committedSize),
MemoryProtection.Read | MemoryProtection.Write | MemoryProtection.Execute,
17, // MAP_SHARED | MAP_FIXED
_fd, IntPtr.Zero);
if (ptr != Z.US(_start))
{
throw new InvalidOperationException($"{nameof(mmap)}() failed with error {Marshal.GetLastWin32Error()}");
}
}
_active = true;
}
public void Deactivate()
{
if (_committedSize > 0)
{
var errorCode = munmap(Z.US(_start), Z.UU(_committedSize));
if (errorCode != 0)
throw new InvalidOperationException($"{nameof(munmap)}() failed with error {Marshal.GetLastWin32Error()}");
}
_active = false;
}
public void Commit(ulong newCommittedSize)
{
var errorCode = ftruncate(_fd, Z.US(newCommittedSize));
if (errorCode != 0)
throw new InvalidOperationException($"{nameof(ftruncate)}() failed with error {Marshal.GetLastWin32Error()}");
// map in the previously unmapped portions contiguously
var ptr = mmap(Z.US(_start + _committedSize), Z.UU(newCommittedSize - _committedSize),
MemoryProtection.Read | MemoryProtection.Write | MemoryProtection.Execute,
17, // MAP_SHARED | MAP_FIXED
_fd, Z.US(_committedSize));
if (ptr != Z.US(_start + _committedSize))
{
throw new InvalidOperationException($"{nameof(mmap)}() failed with error {Marshal.GetLastWin32Error()}");
}
_committedSize = newCommittedSize;
}
private static MemoryProtection ToMemoryProtection(Protection prot)
{
switch (prot)

94
src/BizHawk.BizInvoke/MemoryBlockWindowsPal.cs
View File

@ -6,58 +6,18 @@ namespace BizHawk.BizInvoke
{
internal sealed unsafe class MemoryBlockWindowsPal : IMemoryBlockPal
{
/// <summary>
/// handle returned by CreateFileMapping
/// </summary>
private IntPtr _handle;
private ulong _start;
private ulong _size;
private bool _active;
public ulong Start { get; }
private readonly ulong _size;
private bool _disposed;
/// <summary>
/// Reserve bytes to later be swapped in, but do not map them
/// </summary>
/// <param name="start">eventual mapped address</param>
/// <param name="size"></param>
public MemoryBlockWindowsPal(ulong start, ulong size)
public MemoryBlockWindowsPal(ulong size)
{
_start = start;
var ptr = (ulong)Kernel32.VirtualAlloc(
UIntPtr.Zero, Z.UU(size), Kernel32.AllocationType.MEM_RESERVE | Kernel32.AllocationType.MEM_COMMIT, Kernel32.MemoryProtection.NOACCESS);
if (ptr == 0)
throw new InvalidOperationException($"{nameof(Kernel32.VirtualAlloc)}() returned NULL");
Start = ptr;
_size = size;
_handle = Kernel32.CreateFileMapping(
Kernel32.INVALID_HANDLE_VALUE,
IntPtr.Zero,
Kernel32.FileMapProtection.PageExecuteReadWrite | Kernel32.FileMapProtection.SectionReserve,
(uint)(_size >> 32),
(uint)_size,
null
);
if (_handle == IntPtr.Zero)
{
throw new InvalidOperationException($"{nameof(Kernel32.CreateFileMapping)}() returned NULL");
}
}
public void Activate()
{
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($"{nameof(Kernel32.MapViewOfFileEx)}() returned NULL");
}
_active = true;
}
public void Deactivate()
{
if (!Kernel32.UnmapViewOfFile(Z.US(_start)))
throw new InvalidOperationException($"{nameof(Kernel32.UnmapViewOfFile)}() returned NULL");
_active = false;
}
public void Protect(ulong start, ulong size, Protection prot)
@ -66,12 +26,6 @@ namespace BizHawk.BizInvoke
throw new InvalidOperationException($"{nameof(Kernel32.VirtualProtect)}() returned FALSE!");
}
public void Commit(ulong length)
{
if (Kernel32.VirtualAlloc(Z.UU(_start), Z.UU(length), Kernel32.AllocationType.MEM_COMMIT, Kernel32.MemoryProtection.READWRITE) != Z.UU(_start))
throw new InvalidOperationException($"{nameof(Kernel32.VirtualAlloc)}() returned NULL!");
}
private static Kernel32.MemoryProtection GetKernelMemoryProtectionValue(Protection prot)
{
Kernel32.MemoryProtection p;
@ -88,21 +42,11 @@ namespace BizHawk.BizInvoke
public void Dispose()
{
if (_handle != IntPtr.Zero)
{
if (_active)
{
try
{
Deactivate();
}
catch
{}
}
Kernel32.CloseHandle(_handle);
_handle = IntPtr.Zero;
GC.SuppressFinalize(this);
}
if (_disposed)
return;
Kernel32.VirtualFree(Z.UU(Start), UIntPtr.Zero, Kernel32.FreeType.Release);
_disposed = true;
GC.SuppressFinalize(this);
}
~MemoryBlockWindowsPal()
@ -222,6 +166,16 @@ namespace BizHawk.BizInvoke
[DllImport("kernel32.dll")]
public static extern UIntPtr VirtualQuery(UIntPtr lpAddress, MEMORY_BASIC_INFORMATION* lpBuffer, UIntPtr dwLength);
[Flags]
public enum FreeType
{
Decommit = 0x4000,
Release = 0x8000,
}
[DllImport("kernel32.dll")]
public static extern bool VirtualFree(UIntPtr lpAddress, UIntPtr dwSize, FreeType dwFreeType);
}
}
}