From 37dc9908d01aa21dc7957085e1e04a46aff84f25 Mon Sep 17 00:00:00 2001 From: nattthebear Date: Sat, 27 May 2017 16:18:38 -0400 Subject: [PATCH] Waterbox: Add XOR based savestates for GPGX64 --- .../Consoles/Nintendo/SNES9X/Snes9x.cs | 2 + BizHawk.Emulation.Cores/Waterbox/Heap.cs | 11 +- .../Waterbox/MemoryBlock.cs | 132 ++++++++++++++++-- BizHawk.Emulation.Cores/Waterbox/PeRunner.cs | 10 ++ BizHawk.Emulation.Cores/Waterbox/PeWrapper.cs | 7 +- 5 files changed, 147 insertions(+), 15 deletions(-) diff --git a/BizHawk.Emulation.Cores/Consoles/Nintendo/SNES9X/Snes9x.cs b/BizHawk.Emulation.Cores/Consoles/Nintendo/SNES9X/Snes9x.cs index 4c9ca9ac13..b80ba3bd88 100644 --- a/BizHawk.Emulation.Cores/Consoles/Nintendo/SNES9X/Snes9x.cs +++ b/BizHawk.Emulation.Cores/Consoles/Nintendo/SNES9X/Snes9x.cs @@ -53,6 +53,8 @@ namespace BizHawk.Emulation.Cores.Nintendo.SNES9X VsyncNumerator = 21281370; VsyncDenominator = 425568; } + + _exe.Seal(); } catch { diff --git a/BizHawk.Emulation.Cores/Waterbox/Heap.cs b/BizHawk.Emulation.Cores/Waterbox/Heap.cs index af89729544..44fc21e2ad 100644 --- a/BizHawk.Emulation.Cores/Waterbox/Heap.cs +++ b/BizHawk.Emulation.Cores/Waterbox/Heap.cs @@ -89,7 +89,8 @@ namespace BizHawk.Emulation.Cores.Waterbox bw.Write(Used); if (!Sealed) { - var ms = Memory.GetStream(Memory.Start, Used, false); + bw.Write(Memory.XorHash); + var ms = Memory.GetXorStream(Memory.Start, Used, false); ms.CopyTo(bw.BaseStream); } else @@ -108,9 +109,15 @@ namespace BizHawk.Emulation.Cores.Waterbox throw new InvalidOperationException(string.Format("Heap {0} used {1} larger than available {2}", Name, used, Memory.Size)); if (!Sealed) { + var hash = br.ReadBytes(Memory.XorHash.Length); + if (!hash.SequenceEqual(Memory.XorHash)) + { + throw new InvalidOperationException(string.Format("Hash did not match for heap {0}. Is this the same rom?", Name)); + } + 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); + var ms = Memory.GetXorStream(Memory.Start, used, true); WaterboxUtils.CopySome(br.BaseStream, ms, (long)used); Used = used; } diff --git a/BizHawk.Emulation.Cores/Waterbox/MemoryBlock.cs b/BizHawk.Emulation.Cores/Waterbox/MemoryBlock.cs index beaf8b45ab..3ec79c374c 100644 --- a/BizHawk.Emulation.Cores/Waterbox/MemoryBlock.cs +++ b/BizHawk.Emulation.Cores/Waterbox/MemoryBlock.cs @@ -7,6 +7,10 @@ using System.IO; namespace BizHawk.Emulation.Cores.Waterbox { + // C# is annoying: arithmetic operators for native ints are not exposed. + // So we store them as long/ulong instead in many places, and use these helpers + // to convert to IntPtr when needed + public static class Z { public static IntPtr US(ulong l) @@ -47,7 +51,7 @@ namespace BizHawk.Emulation.Cores.Waterbox /// /// system page size /// - public static int PageSize { get; private set;} + public static int PageSize { get; private set; } /// /// bitshift corresponding to PageSize @@ -68,7 +72,7 @@ namespace BizHawk.Emulation.Cores.Waterbox } PageMask = (ulong)(PageSize - 1); } - + /// /// true if addr is aligned /// @@ -121,6 +125,13 @@ namespace BizHawk.Emulation.Cores.Waterbox /// private readonly Protection[] _pageData; + /// + /// snapshot for XOR buffer + /// + private byte[] _snapshot; + + public byte[] XorHash { get; private set; } + /// /// get a page index within the block /// @@ -216,13 +227,53 @@ namespace BizHawk.Emulation.Cores.Waterbox { if (start < Start) throw new ArgumentOutOfRangeException(nameof(start)); - if (start + length > End) throw new ArgumentOutOfRangeException(nameof(length)); return new MemoryViewStream(!writer, writer, (long)start, (long)length, this); } + /// + /// get a stream that can be used to read or write from part of the block. + /// both reads and writes will be XORed against an earlier recorded snapshot + /// + public Stream GetXorStream(ulong start, ulong length, bool writer) + { + if (start < Start) + throw new ArgumentOutOfRangeException(nameof(start)); + if (start + length > End) + throw new ArgumentOutOfRangeException(nameof(length)); + if (_snapshot == null) + throw new InvalidOperationException("No snapshot taken!"); + + return new MemoryViewXorStream(!writer, writer, (long)start, (long)length, this, _snapshot, (long)(start - Start)); + } + + /// + /// take a snapshot of the entire memory block's contents, for use in GetXorStream + /// + public void SaveXorSnapshot() + { + if (_snapshot != null) + throw new InvalidOperationException("Snapshot already taken"); + if (!Active) + throw new InvalidOperationException("Not active"); + + // temporarily switch the entire block to `R`: in case some areas are unreadable, we don't want + // that to complicate things + Kernel32.MemoryProtection old; + if (!Kernel32.VirtualProtect(Z.UU(Start), Z.UU(Size), Kernel32.MemoryProtection.READONLY, out old)) + throw new InvalidOperationException("VirtualProtect() returned FALSE!"); + + _snapshot = new byte[Size]; + var ds = new MemoryStream(_snapshot, true); + var ss = GetStream(Start, Size, false); + ss.CopyTo(ds); + XorHash = WaterboxUtils.Hash(_snapshot); + + ProtectAll(); + } + private static Kernel32.MemoryProtection GetKernelMemoryProtectionValue(Protection prot) { Kernel32.MemoryProtection p; @@ -338,24 +389,25 @@ namespace BizHawk.Emulation.Cores.Waterbox public override long Length { get { return _length; } } public override long Position - { - get { return _pos; } set + { + get { return _pos; } + set { if (value < 0 || value > _length) throw new ArgumentOutOfRangeException(); _pos = value; - } + } } public override int Read(byte[] buffer, int offset, int count) { if (!_readable) throw new InvalidOperationException(); - if (count < 0 || count > buffer.Length) + if (count < 0 || count + offset > buffer.Length) throw new ArgumentOutOfRangeException(); EnsureNotDisposed(); count = (int)Math.Min(count, _length - _pos); - Marshal.Copy(Z.SS(_ptr + _pos), buffer, 0, count); + Marshal.Copy(Z.SS(_ptr + _pos), buffer, offset, count); _pos += count; return count; } @@ -389,15 +441,73 @@ namespace BizHawk.Emulation.Cores.Waterbox { if (!_writable) throw new InvalidOperationException(); - if (count < 0 || count > buffer.Length) + if (count < 0 || count + offset > buffer.Length) + throw new ArgumentOutOfRangeException(); + if (count > _length - _pos) throw new ArgumentOutOfRangeException(); EnsureNotDisposed(); - count = (int)Math.Min(count, _length - _pos); - Marshal.Copy(buffer, 0, Z.SS(_ptr + _pos), count); + Marshal.Copy(buffer, offset, Z.SS(_ptr + _pos), count); _pos += count; } } + private class MemoryViewXorStream : MemoryViewStream + { + public MemoryViewXorStream(bool readable, bool writable, long ptr, long length, MemoryBlock owner, + byte[] initial, long offset) + : base(readable, writable, ptr, length, owner) + { + _initial = initial; + _offset = (int)offset; + } + + /// + /// the initial data to XOR against for both reading and writing + /// + private byte[] _initial; + /// + /// offset into the XOR data that this stream is representing + /// + private int _offset; + + public override int Read(byte[] buffer, int offset, int count) + { + int pos = (int)Position; + count = base.Read(buffer, offset, count); + XorTransform(_initial, _offset + pos, buffer, offset, count); + return count; + } + + public override void Write(byte[] buffer, int offset, int count) + { + int pos = (int)Position; + if (count < 0 || count + offset > buffer.Length) + throw new ArgumentOutOfRangeException(); + if (count > Length - pos) + throw new ArgumentOutOfRangeException(); + // is mutating the buffer passed to Stream.Write kosher? + XorTransform(_initial, _offset + pos, buffer, offset, count); + base.Write(buffer, offset, count); + } + + private static unsafe void XorTransform(byte[] source, int sourceOffset, byte[] dest, int destOffset, int length) + { + // we don't do any bounds check because MemoryViewStream.Read and MemoryViewXorStream.Write already did it + + // TODO: C compilers can make this pretty snappy, but can the C# jitter? Or do we need intrinsics + fixed (byte* _s = source, _d = dest) + { + byte* s = _s + sourceOffset; + byte* d = _d + destOffset; + byte* sEnd = s + length; + while (s < sEnd) + { + *d++ ^= *s++; + } + } + } + } + private static class Kernel32 { [DllImport("kernel32.dll", SetLastError = true)] diff --git a/BizHawk.Emulation.Cores/Waterbox/PeRunner.cs b/BizHawk.Emulation.Cores/Waterbox/PeRunner.cs index f78068e06e..dc230ca2d2 100644 --- a/BizHawk.Emulation.Cores/Waterbox/PeRunner.cs +++ b/BizHawk.Emulation.Cores/Waterbox/PeRunner.cs @@ -519,6 +519,11 @@ namespace BizHawk.Emulation.Cores.Waterbox /// private readonly List _modules = new List(); + /// + /// all loaded heaps + /// + private readonly List _heaps = new List(); + /// /// anything at all that needs to be disposed on finish /// @@ -553,6 +558,7 @@ namespace BizHawk.Emulation.Cores.Waterbox if (saveStated) _savestateComponents.Add(heap); _disposeList.Add(heap); + _heaps.Add(heap); return heap; } @@ -663,6 +669,10 @@ namespace BizHawk.Emulation.Cores.Waterbox using (this.EnterExit()) { _sealedheap.Seal(); + foreach (var h in _heaps) + h.Memory.SaveXorSnapshot(); + foreach (var pe in _modules) + pe.Memory.SaveXorSnapshot(); } } diff --git a/BizHawk.Emulation.Cores/Waterbox/PeWrapper.cs b/BizHawk.Emulation.Cores/Waterbox/PeWrapper.cs index fb900805ac..23b9810f01 100644 --- a/BizHawk.Emulation.Cores/Waterbox/PeWrapper.cs +++ b/BizHawk.Emulation.Cores/Waterbox/PeWrapper.cs @@ -292,6 +292,7 @@ namespace BizHawk.Emulation.Cores.Waterbox { bw.Write(MAGIC); bw.Write(_fileHash); + bw.Write(Memory.XorHash); bw.Write(Start); foreach (var s in _pe.ImageSectionHeaders) @@ -302,7 +303,7 @@ namespace BizHawk.Emulation.Cores.Waterbox ulong start = Start + s.VirtualAddress; ulong length = s.VirtualSize; - var ms = Memory.GetStream(start, length, false); + var ms = Memory.GetXorStream(start, length, false); bw.Write(length); ms.CopyTo(bw.BaseStream); } @@ -314,6 +315,8 @@ namespace BizHawk.Emulation.Cores.Waterbox throw new InvalidOperationException("Magic not magic enough!"); if (!br.ReadBytes(_fileHash.Length).SequenceEqual(_fileHash)) throw new InvalidOperationException("Elf changed disguise!"); + if (!br.ReadBytes(Memory.XorHash.Length).SequenceEqual(Memory.XorHash)) + throw new InvalidOperationException("Elf is super slippery!"); if (br.ReadUInt64() != Start) throw new InvalidOperationException("Trickys elves moved on you!"); @@ -330,7 +333,7 @@ namespace BizHawk.Emulation.Cores.Waterbox if (br.ReadUInt64() != length) throw new InvalidOperationException("Unexpected section size for " + s.Name); - var ms = Memory.GetStream(start, length, true); + var ms = Memory.GetXorStream(start, length, true); WaterboxUtils.CopySome(br.BaseStream, ms, (long)length); }