mirror of
https://github.com/par274/sharpemu.git
synced 2026-07-31 23:19:44 +08:00
[AGC/Vulkan] Extend PS5 runtime and rendering compatibility (#216)
* [Core] Add POSIX native execution and PS5 SELF support Extend the native backend, guest TLS, fixed-address memory, and loader paths needed by PS5 titles on Windows, Linux, and macOS. Keep workstation GC so high-core-count hosts do not reserve over fixed guest image bases. * [HLE] Expand PS5 service and media compatibility Add the kernel, threading, save-data, networking, audio, video-codec, font, dialog, and service exports required by newer PS5 software. Preserve every SysAbi NID currently registered by main while adding the compatibility surface used by ASTRO BOT. * [AGC/Vulkan] Extend Gen5 shader and presentation support Expand PM4 handling, Gen5 shader translation, MRT and packed export support, guest image tracking, depth initialization, texture aliasing, and Vulkan presentation. Add the performance overlay and address-filtered diagnostics used to validate ASTRO BOT with original shaders. * [Core] Align static TLS reservation across hosts * [Pad] Align primary user ID with UserService * [Gpu] Preserve runtime scalar buffers across renderer seam * [AGC] Restore omitted command helper exports * [Vulkan] Reuse primary views for promoted MRT targets * [Vulkan] Preserve scratch storage bindings in compute dispatches
This commit is contained in:
Miguel Cruz
@@ -26,6 +26,12 @@ public sealed class CpuContext(ICpuMemory memory, Generation generation)
|
||||
|
||||
public ulong GsBase { get; set; }
|
||||
|
||||
/// <summary>x87 control word observed at the current guest boundary.</summary>
|
||||
public ushort FpuControlWord { get; set; } = 0x037F;
|
||||
|
||||
/// <summary>MXCSR observed at the current guest boundary.</summary>
|
||||
public uint Mxcsr { get; set; } = 0x1F80;
|
||||
|
||||
public ulong this[CpuRegister register]
|
||||
{
|
||||
get => _registers[(int)register];
|
||||
|
||||
@@ -0,0 +1,613 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
using System.Globalization;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace SharpEmu.HLE;
|
||||
|
||||
/// <summary>
|
||||
/// Detects guest CPU writes into memory that backs a host GPU image. On PS5
|
||||
/// render targets alias unified memory, so games freely mix CPU writes and GPU
|
||||
/// draws on the same surface (Chowdren titles memset their fog layers every
|
||||
/// frame). Host GPU images are separate storage, so the video backend needs to
|
||||
/// know when the guest CPU rewrote a surface to re-upload it. Ranges are
|
||||
/// write-protected; the first write faults, the fault handler restores write
|
||||
/// access and marks the range dirty, and the video backend consumes the dirty
|
||||
/// flag once per flip and re-arms protection after re-uploading.
|
||||
/// </summary>
|
||||
public static unsafe class GuestImageWriteTracker
|
||||
{
|
||||
private const int ProtRead = 0x1;
|
||||
private const int ProtWrite = 0x2;
|
||||
private const int ClockMonotonicRaw = 4;
|
||||
|
||||
private sealed class TrackedRange
|
||||
{
|
||||
public ulong Address;
|
||||
public ulong ByteCount;
|
||||
public ulong Start;
|
||||
public ulong End;
|
||||
public int Dirty;
|
||||
public int Armed;
|
||||
public int FirstCpuWriteSeen;
|
||||
public int PendingFirstCpuWrite;
|
||||
public bool TraceLifetime;
|
||||
public long SourceSequence;
|
||||
public long FirstCpuWriteTraceSequence;
|
||||
public long FirstCpuWriteTimestampNanoseconds;
|
||||
public ulong FirstCpuWriteAddress;
|
||||
public ulong FirstCpuWritePage;
|
||||
public string Source = "unspecified";
|
||||
}
|
||||
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct Timespec
|
||||
{
|
||||
public long Seconds;
|
||||
public long Nanoseconds;
|
||||
}
|
||||
|
||||
private static readonly object _gate = new();
|
||||
private static readonly Dictionary<ulong, TrackedRange> _rangesByAddress = new();
|
||||
|
||||
// Snapshot array read lock-free from the signal handler; rebuilt on every
|
||||
// mutation under the gate. Signal handlers must not take managed locks.
|
||||
private static TrackedRange[] _rangeSnapshot = [];
|
||||
|
||||
private static readonly bool _enabled = !OperatingSystem.IsWindows() &&
|
||||
Environment.GetEnvironmentVariable("SHARPEMU_GUEST_IMAGE_CPU_SYNC") != "0";
|
||||
private static readonly (bool Wildcard, ulong[] Addresses) _lifetimeTraceFilter =
|
||||
ParseAddressList(Environment.GetEnvironmentVariable("SHARPEMU_TRACE_GUEST_IMAGE_ADDRS"));
|
||||
private static readonly (bool Wildcard, string[] Sources) _lifetimeSourceTraceFilter =
|
||||
ParseSourceList(Environment.GetEnvironmentVariable("SHARPEMU_TRACE_GUEST_MEMORY_LIFETIME"));
|
||||
private static readonly bool _lifetimeTraceEnabled =
|
||||
_lifetimeTraceFilter.Wildcard ||
|
||||
_lifetimeTraceFilter.Addresses.Length != 0 ||
|
||||
_lifetimeSourceTraceFilter.Wildcard ||
|
||||
_lifetimeSourceTraceFilter.Sources.Length != 0;
|
||||
private static readonly long _lifetimeTraceEpochNanoseconds =
|
||||
_enabled && _lifetimeTraceEnabled ? GetMonotonicNanoseconds() : 0;
|
||||
private static long _lifetimeTraceSequence;
|
||||
|
||||
[DllImport("libc", EntryPoint = "mprotect", SetLastError = true)]
|
||||
private static extern int Mprotect(nint address, nuint length, int protection);
|
||||
|
||||
[DllImport("libc", EntryPoint = "clock_gettime", SetLastError = false)]
|
||||
private static extern int ClockGetTime(int clockId, Timespec* time);
|
||||
|
||||
public static bool Enabled => _enabled;
|
||||
|
||||
/// <summary>
|
||||
/// Exercises the fault-handling path once outside signal context so every
|
||||
/// branch is JIT-compiled (and, under Rosetta 2, translated) before a real
|
||||
/// fault arrives — a cold signal path is silently never entered there.
|
||||
/// </summary>
|
||||
public static void WarmUp()
|
||||
{
|
||||
if (!_enabled)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var scratch = NativeMemory.AllocZeroed(4096);
|
||||
try
|
||||
{
|
||||
// Warm the timestamp P/Invoke used by the signal-safe scalar
|
||||
// capture path before a real protected-page write reaches it.
|
||||
_ = GetMonotonicNanoseconds();
|
||||
var address = (ulong)scratch;
|
||||
Track(address, 4096);
|
||||
_ = TryHandleWriteFault(address);
|
||||
_ = ConsumeDirty(address);
|
||||
Untrack(address);
|
||||
}
|
||||
finally
|
||||
{
|
||||
NativeMemory.Free(scratch);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Registers a range and arms write protection on it.</summary>
|
||||
public static void Track(
|
||||
ulong address,
|
||||
ulong byteCount,
|
||||
long sourceSequence = 0,
|
||||
string source = "unspecified")
|
||||
{
|
||||
if (!_enabled || address == 0 || byteCount == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var (start, length) = PageAlign(address, byteCount);
|
||||
lock (_gate)
|
||||
{
|
||||
_rangesByAddress.TryGetValue(address, out var range);
|
||||
if (range is not null &&
|
||||
(range.Start != start ||
|
||||
range.End != start + length ||
|
||||
range.ByteCount != byteCount))
|
||||
{
|
||||
// Never resize an object that is still reachable from the
|
||||
// signal handler's lock-free snapshot. Retire it and publish
|
||||
// a fresh immutable range.
|
||||
DisarmLocked(range, "replace-range");
|
||||
_rangesByAddress.Remove(address);
|
||||
range = null;
|
||||
}
|
||||
|
||||
if (range is null)
|
||||
{
|
||||
range = new TrackedRange
|
||||
{
|
||||
Address = address,
|
||||
ByteCount = byteCount,
|
||||
Start = start,
|
||||
End = start + length,
|
||||
TraceLifetime =
|
||||
ShouldTraceRange(start, start + length) || ShouldTraceSource(source),
|
||||
SourceSequence = sourceSequence,
|
||||
Source = source,
|
||||
};
|
||||
_rangesByAddress[address] = range;
|
||||
RebuildSnapshotLocked();
|
||||
}
|
||||
else
|
||||
{
|
||||
FlushPendingFirstCpuWrite(range);
|
||||
}
|
||||
|
||||
range.SourceSequence = sourceSequence;
|
||||
range.Source = source;
|
||||
range.TraceLifetime =
|
||||
ShouldTraceRange(range.Start, range.End) || ShouldTraceSource(source);
|
||||
ArmLocked(range, "arm");
|
||||
}
|
||||
}
|
||||
|
||||
public static void Untrack(ulong address)
|
||||
{
|
||||
if (!_enabled)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (_rangesByAddress.TryGetValue(address, out var range))
|
||||
{
|
||||
DisarmLocked(range, "untrack");
|
||||
_rangesByAddress.Remove(address);
|
||||
RebuildSnapshotLocked();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns true when the guest CPU wrote the range since the last call,
|
||||
/// clearing the flag. The caller re-arms via <see cref="Rearm"/> after it
|
||||
/// finished reading the guest bytes.
|
||||
/// </summary>
|
||||
public static bool ConsumeDirty(ulong address)
|
||||
{
|
||||
if (!_enabled)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_rangesByAddress.TryGetValue(address, out var range))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
FlushPendingFirstCpuWrite(range);
|
||||
return Interlocked.Exchange(ref range.Dirty, 0) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Non-consuming variant of <see cref="ConsumeDirty"/>: reports whether
|
||||
/// the range has been written since it was last re-armed, leaving the
|
||||
/// flag for the owner that evicts and re-uploads.
|
||||
/// </summary>
|
||||
public static bool PeekDirty(ulong address)
|
||||
{
|
||||
if (!_enabled)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_rangesByAddress.TryGetValue(address, out var range))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
FlushPendingFirstCpuWrite(range);
|
||||
return Volatile.Read(ref range.Dirty) != 0;
|
||||
}
|
||||
}
|
||||
|
||||
public static void Rearm(ulong address)
|
||||
{
|
||||
if (!_enabled)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (_rangesByAddress.TryGetValue(address, out var range))
|
||||
{
|
||||
ArmLocked(range, "rearm");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Prepares pages touched by a managed HLE memory write. Native guest
|
||||
/// stores fault and enter <see cref="TryHandleWriteFault"/> through the
|
||||
/// POSIX signal bridge, but a managed Buffer.MemoryCopy into a protected
|
||||
/// page is surfaced by the runtime as a fatal AccessViolation instead of
|
||||
/// a resumable guest fault. Visit every page in the write span up front so
|
||||
/// all overlapping texture owners are dirtied and made writable.
|
||||
/// </summary>
|
||||
public static void NotifyManagedWrite(ulong address, ulong byteCount)
|
||||
{
|
||||
if (!_enabled || address == 0 || byteCount == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
var end = address > ulong.MaxValue - byteCount
|
||||
? ulong.MaxValue
|
||||
: address + byteCount;
|
||||
var candidate = address;
|
||||
while (candidate < end)
|
||||
{
|
||||
_ = TryHandleWriteFault(candidate);
|
||||
var nextPage = (candidate & ~0xFFFUL) + 0x1000UL;
|
||||
if (nextPage <= candidate)
|
||||
{
|
||||
break;
|
||||
}
|
||||
candidate = nextPage;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Flushes scalar first-write records captured by the POSIX signal handler.
|
||||
/// Call only from ordinary managed execution, never from signal context.
|
||||
/// </summary>
|
||||
public static void FlushPendingDiagnostics()
|
||||
{
|
||||
if (!_enabled || !_lifetimeTraceEnabled)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
foreach (var range in _rangesByAddress.Values)
|
||||
{
|
||||
FlushPendingFirstCpuWrite(range);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Signal-handler entry: if the fault address lies in a tracked, armed
|
||||
/// range, restore write access, mark the range dirty, and return true so
|
||||
/// the faulting write can be retried. Must not allocate or lock.
|
||||
/// </summary>
|
||||
public static bool TryHandleWriteFault(ulong faultAddress)
|
||||
{
|
||||
if (!_enabled || faultAddress == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
var ranges = Volatile.Read(ref _rangeSnapshot);
|
||||
var writableStart = ulong.MaxValue;
|
||||
var writableEnd = 0UL;
|
||||
for (var index = 0; index < ranges.Length; index++)
|
||||
{
|
||||
var range = ranges[index];
|
||||
if (faultAddress < range.Start || faultAddress >= range.End)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
writableStart = Math.Min(writableStart, range.Start);
|
||||
writableEnd = Math.Max(writableEnd, range.End);
|
||||
}
|
||||
|
||||
if (writableStart == ulong.MaxValue)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Ranges are page-aligned and may overlap (font atlases and other
|
||||
// suballocations commonly share pages). Unprotecting one range also
|
||||
// makes every overlapping tracked page writable. Expand to the full
|
||||
// transitive overlap and dirty/disarm every owner, otherwise only the
|
||||
// first dictionary entry observes the write and the others retain a
|
||||
// stale cached texture indefinitely.
|
||||
var expanded = true;
|
||||
while (expanded)
|
||||
{
|
||||
expanded = false;
|
||||
for (var index = 0; index < ranges.Length; index++)
|
||||
{
|
||||
var range = ranges[index];
|
||||
if (range.Start >= writableEnd || range.End <= writableStart)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var start = Math.Min(writableStart, range.Start);
|
||||
var end = Math.Max(writableEnd, range.End);
|
||||
if (start != writableStart || end != writableEnd)
|
||||
{
|
||||
writableStart = start;
|
||||
writableEnd = end;
|
||||
expanded = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var needsUnprotect = false;
|
||||
for (var index = 0; index < ranges.Length; index++)
|
||||
{
|
||||
var range = ranges[index];
|
||||
if (range.Start < writableEnd && range.End > writableStart &&
|
||||
Volatile.Read(ref range.Armed) != 0)
|
||||
{
|
||||
needsUnprotect = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (needsUnprotect &&
|
||||
Mprotect(
|
||||
(nint)writableStart,
|
||||
(nuint)(writableEnd - writableStart),
|
||||
ProtRead | ProtWrite) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
for (var index = 0; index < ranges.Length; index++)
|
||||
{
|
||||
var range = ranges[index];
|
||||
if (range.Start >= writableEnd || range.End <= writableStart)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
var wasArmed = Interlocked.Exchange(ref range.Armed, 0) != 0;
|
||||
if (wasArmed &&
|
||||
range.TraceLifetime &&
|
||||
Interlocked.CompareExchange(ref range.FirstCpuWriteSeen, 1, 0) == 0)
|
||||
{
|
||||
// Signal context: capture preallocated scalar fields only.
|
||||
// Formatting and I/O are deferred to a locked safe path.
|
||||
range.FirstCpuWriteTraceSequence =
|
||||
Interlocked.Increment(ref _lifetimeTraceSequence);
|
||||
range.FirstCpuWriteTimestampNanoseconds = GetMonotonicNanoseconds();
|
||||
range.FirstCpuWriteAddress = faultAddress;
|
||||
range.FirstCpuWritePage = faultAddress & ~0xFFFUL;
|
||||
Volatile.Write(ref range.PendingFirstCpuWrite, 1);
|
||||
Volatile.Write(ref range.FirstCpuWriteSeen, 2);
|
||||
}
|
||||
|
||||
Volatile.Write(ref range.Dirty, 1);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void ArmLocked(TrackedRange range, string operation)
|
||||
{
|
||||
FlushPendingFirstCpuWrite(range);
|
||||
if (Interlocked.Exchange(ref range.Armed, 1) == 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// A new publication/rearm starts a new first-write lifetime.
|
||||
Volatile.Write(ref range.FirstCpuWriteSeen, 0);
|
||||
var failed = Mprotect(
|
||||
(nint)range.Start,
|
||||
(nuint)(range.End - range.Start),
|
||||
ProtRead) != 0;
|
||||
if (failed)
|
||||
{
|
||||
Volatile.Write(ref range.Armed, 0);
|
||||
}
|
||||
|
||||
if (range.TraceLifetime)
|
||||
{
|
||||
TraceLifetime(
|
||||
range,
|
||||
failed ? $"{operation}-failed-errno-{Marshal.GetLastPInvokeError()}" : operation);
|
||||
}
|
||||
}
|
||||
|
||||
private static void DisarmLocked(TrackedRange range, string operation)
|
||||
{
|
||||
FlushPendingFirstCpuWrite(range);
|
||||
var wasArmed = Interlocked.Exchange(ref range.Armed, 0) == 1;
|
||||
if (wasArmed)
|
||||
{
|
||||
_ = Mprotect(
|
||||
(nint)range.Start,
|
||||
(nuint)(range.End - range.Start),
|
||||
ProtRead | ProtWrite);
|
||||
}
|
||||
|
||||
if (range.TraceLifetime)
|
||||
{
|
||||
TraceLifetime(range, wasArmed ? operation : $"{operation}-already-disarmed");
|
||||
}
|
||||
}
|
||||
|
||||
private static void RebuildSnapshotLocked()
|
||||
{
|
||||
_rangeSnapshot = _rangesByAddress.Values.ToArray();
|
||||
}
|
||||
|
||||
private static (ulong Start, ulong Length) PageAlign(ulong address, ulong byteCount)
|
||||
{
|
||||
const ulong pageMask = 0xFFFUL;
|
||||
var start = address & ~pageMask;
|
||||
var end = (address + byteCount + pageMask) & ~pageMask;
|
||||
return (start, end - start);
|
||||
}
|
||||
|
||||
private static bool ShouldTraceRange(ulong start, ulong end)
|
||||
{
|
||||
if (_lifetimeTraceFilter.Wildcard)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
var addresses = _lifetimeTraceFilter.Addresses;
|
||||
for (var index = 0; index < addresses.Length; index++)
|
||||
{
|
||||
if (addresses[index] >= start && addresses[index] < end)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private static (bool Wildcard, ulong[] Addresses) ParseAddressList(string? addresses)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(addresses))
|
||||
{
|
||||
return (false, []);
|
||||
}
|
||||
|
||||
var parsedAddresses = new List<ulong>();
|
||||
foreach (var token in addresses.Split(
|
||||
[',', ';', ' ', '\t'],
|
||||
StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
|
||||
{
|
||||
if (token == "*")
|
||||
{
|
||||
return (true, []);
|
||||
}
|
||||
|
||||
var span = token.AsSpan();
|
||||
if (span.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
span = span[2..];
|
||||
}
|
||||
|
||||
if (ulong.TryParse(span, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var parsed))
|
||||
{
|
||||
parsedAddresses.Add(parsed);
|
||||
}
|
||||
}
|
||||
|
||||
return (false, parsedAddresses.ToArray());
|
||||
}
|
||||
|
||||
private static bool ShouldTraceSource(string source)
|
||||
{
|
||||
if (_lifetimeSourceTraceFilter.Wildcard)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return Array.IndexOf(_lifetimeSourceTraceFilter.Sources, source) >= 0;
|
||||
}
|
||||
|
||||
private static (bool Wildcard, string[] Sources) ParseSourceList(string? sources)
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(sources))
|
||||
{
|
||||
return (false, []);
|
||||
}
|
||||
|
||||
var parsedSources = new List<string>();
|
||||
foreach (var token in sources.Split(
|
||||
[',', ';'],
|
||||
StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
|
||||
{
|
||||
if (token == "*")
|
||||
{
|
||||
return (true, []);
|
||||
}
|
||||
|
||||
parsedSources.Add(token);
|
||||
}
|
||||
|
||||
return (false, parsedSources.ToArray());
|
||||
}
|
||||
|
||||
private static void FlushPendingFirstCpuWrite(TrackedRange range)
|
||||
{
|
||||
var spin = new SpinWait();
|
||||
while (Volatile.Read(ref range.FirstCpuWriteSeen) == 1)
|
||||
{
|
||||
spin.SpinOnce();
|
||||
}
|
||||
|
||||
if (!range.TraceLifetime || Interlocked.Exchange(ref range.PendingFirstCpuWrite, 0) == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
TraceLifetime(
|
||||
range,
|
||||
"first-cpu-write-disarm",
|
||||
range.FirstCpuWriteAddress,
|
||||
range.FirstCpuWritePage,
|
||||
range.FirstCpuWriteTraceSequence,
|
||||
range.FirstCpuWriteTimestampNanoseconds);
|
||||
}
|
||||
|
||||
private static void TraceLifetime(
|
||||
TrackedRange range,
|
||||
string operation,
|
||||
ulong faultAddress = 0,
|
||||
ulong faultPage = 0,
|
||||
long traceSequence = 0,
|
||||
long timestampNanoseconds = 0)
|
||||
{
|
||||
if (traceSequence == 0)
|
||||
{
|
||||
traceSequence = Interlocked.Increment(ref _lifetimeTraceSequence);
|
||||
}
|
||||
|
||||
if (timestampNanoseconds == 0)
|
||||
{
|
||||
timestampNanoseconds = GetMonotonicNanoseconds();
|
||||
}
|
||||
|
||||
var elapsedMilliseconds =
|
||||
(timestampNanoseconds - _lifetimeTraceEpochNanoseconds) / 1_000_000.0;
|
||||
Console.Error.WriteLine(
|
||||
$"[WT][LIFETIME] seq={traceSequence} t_ms={elapsedMilliseconds:F3} " +
|
||||
$"event={operation} source_seq={range.SourceSequence} source='{range.Source}' " +
|
||||
$"requested=0x{range.Address:X16}+0x{range.ByteCount:X} " +
|
||||
$"range=0x{range.Start:X16}..0x{range.End:X16} " +
|
||||
$"fault=0x{faultAddress:X16} page=0x{faultPage:X16}");
|
||||
}
|
||||
|
||||
private static long GetMonotonicNanoseconds()
|
||||
{
|
||||
Timespec time;
|
||||
return ClockGetTime(ClockMonotonicRaw, &time) == 0
|
||||
? unchecked((time.Seconds * 1_000_000_000L) + time.Nanoseconds)
|
||||
: 0;
|
||||
}
|
||||
}
|
||||
@@ -41,6 +41,14 @@ public interface IGuestThreadScheduler
|
||||
{
|
||||
bool SupportsGuestContextTransfer { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Associates a pthread identity created on the primary guest executor
|
||||
/// with its live CPU context. Primary execution does not pass through
|
||||
/// TryStartThread, but kernel exception delivery must still be able to
|
||||
/// target it.
|
||||
/// </summary>
|
||||
void RegisterGuestThreadContext(ulong threadHandle, CpuContext context);
|
||||
|
||||
bool TryStartThread(CpuContext creatorContext, GuestThreadStartRequest request, out string? error);
|
||||
|
||||
bool TryJoinThread(
|
||||
@@ -53,6 +61,19 @@ public interface IGuestThreadScheduler
|
||||
|
||||
int WakeBlockedThreads(string wakeKey, int maxCount = int.MaxValue);
|
||||
|
||||
/// <summary>
|
||||
/// Applies a new guest scheduling priority to a live thread, mapping it
|
||||
/// onto the host thread if one is running. Returns false when the thread
|
||||
/// handle is unknown.
|
||||
/// </summary>
|
||||
bool TrySetGuestThreadPriority(ulong guestThreadHandle, int guestPriority);
|
||||
|
||||
/// <summary>
|
||||
/// Records a new affinity mask for a guest thread and re-applies it to
|
||||
/// the host thread where the platform supports it.
|
||||
/// </summary>
|
||||
bool TrySetGuestThreadAffinity(ulong guestThreadHandle, ulong affinityMask);
|
||||
|
||||
IReadOnlyList<GuestThreadSnapshot> SnapshotThreads();
|
||||
|
||||
bool TryCallGuestFunction(
|
||||
@@ -65,11 +86,36 @@ public interface IGuestThreadScheduler
|
||||
string reason,
|
||||
out string? error);
|
||||
|
||||
bool TryCallGuestFunction(
|
||||
CpuContext callerContext,
|
||||
ulong entryPoint,
|
||||
ulong arg0,
|
||||
ulong arg1,
|
||||
ulong arg2,
|
||||
ulong stackAddress,
|
||||
ulong stackSize,
|
||||
string reason,
|
||||
out ulong returnValue,
|
||||
out string? error);
|
||||
|
||||
bool TryCallGuestContinuation(
|
||||
CpuContext callerContext,
|
||||
GuestCpuContinuation continuation,
|
||||
string reason,
|
||||
out string? error);
|
||||
|
||||
/// <summary>
|
||||
/// Asynchronously invokes an installed kernel exception handler as the
|
||||
/// target guest thread. This is used by IL2CPP's stop-the-world collector:
|
||||
/// the handler acknowledges suspension and may remain blocked until the
|
||||
/// collecting thread resumes it.
|
||||
/// </summary>
|
||||
bool TryRaiseGuestException(
|
||||
CpuContext callerContext,
|
||||
ulong threadHandle,
|
||||
ulong handler,
|
||||
int exceptionType,
|
||||
out string? error);
|
||||
}
|
||||
|
||||
public readonly record struct GuestImportCallFrame(
|
||||
@@ -94,13 +140,34 @@ public readonly record struct GuestCpuContinuation(
|
||||
ulong Rdi,
|
||||
ulong R8,
|
||||
ulong R9,
|
||||
ulong R10,
|
||||
ulong R11,
|
||||
ulong R12,
|
||||
ulong R13,
|
||||
ulong R14,
|
||||
ulong R15);
|
||||
ulong R15,
|
||||
ushort FpuControlWord,
|
||||
uint Mxcsr,
|
||||
bool RestoreFullFpuState);
|
||||
|
||||
public static class GuestThreadExecution
|
||||
{
|
||||
private sealed class DelegateGuestThreadBlockWaiter : IGuestThreadBlockWaiter
|
||||
{
|
||||
private readonly Func<int> _resume;
|
||||
private readonly Func<bool> _tryWake;
|
||||
|
||||
public DelegateGuestThreadBlockWaiter(Func<int> resume, Func<bool> tryWake)
|
||||
{
|
||||
_resume = resume;
|
||||
_tryWake = tryWake;
|
||||
}
|
||||
|
||||
public int Resume() => _resume();
|
||||
|
||||
public bool TryWake() => _tryWake();
|
||||
}
|
||||
|
||||
[ThreadStatic]
|
||||
private static ulong _currentGuestThreadHandle;
|
||||
|
||||
@@ -246,6 +313,23 @@ public static class GuestThreadExecution
|
||||
return true;
|
||||
}
|
||||
|
||||
// Compatibility bridge for exports that still describe blocked work as a
|
||||
// resume/wake delegate pair. New hot paths should provide an
|
||||
// IGuestThreadBlockWaiter directly to avoid allocating closures.
|
||||
public static bool RequestCurrentThreadBlock(
|
||||
CpuContext? context,
|
||||
string reason,
|
||||
string? wakeKey,
|
||||
Func<int> resumeHandler,
|
||||
Func<bool> wakeHandler,
|
||||
long blockDeadlineTimestamp = 0) =>
|
||||
RequestCurrentThreadBlock(
|
||||
context,
|
||||
reason,
|
||||
wakeKey,
|
||||
new DelegateGuestThreadBlockWaiter(resumeHandler, wakeHandler),
|
||||
blockDeadlineTimestamp);
|
||||
|
||||
public static bool TryConsumeCurrentThreadBlock(out string reason)
|
||||
{
|
||||
return TryConsumeCurrentThreadBlock(out reason, out _, out _);
|
||||
@@ -314,6 +398,27 @@ public static class GuestThreadExecution
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool TryConsumeCurrentThreadBlock(
|
||||
out string reason,
|
||||
out GuestCpuContinuation continuation,
|
||||
out bool hasContinuation,
|
||||
out string wakeKey,
|
||||
out Func<int>? resumeHandler,
|
||||
out Func<bool>? wakeHandler,
|
||||
out long blockDeadlineTimestamp)
|
||||
{
|
||||
var consumed = TryConsumeCurrentThreadBlock(
|
||||
out reason,
|
||||
out continuation,
|
||||
out hasContinuation,
|
||||
out wakeKey,
|
||||
out var waiter,
|
||||
out blockDeadlineTimestamp);
|
||||
resumeHandler = waiter is null ? null : waiter.Resume;
|
||||
wakeHandler = waiter is null ? null : waiter.TryWake;
|
||||
return consumed;
|
||||
}
|
||||
|
||||
public static long ComputeDeadlineTimestamp(TimeSpan timeout)
|
||||
{
|
||||
if (timeout <= TimeSpan.Zero)
|
||||
@@ -360,10 +465,15 @@ public static class GuestThreadExecution
|
||||
context[CpuRegister.Rdi],
|
||||
context[CpuRegister.R8],
|
||||
context[CpuRegister.R9],
|
||||
context[CpuRegister.R10],
|
||||
context[CpuRegister.R11],
|
||||
context[CpuRegister.R12],
|
||||
context[CpuRegister.R13],
|
||||
context[CpuRegister.R14],
|
||||
context[CpuRegister.R15]);
|
||||
context[CpuRegister.R15],
|
||||
context.FpuControlWord,
|
||||
context.Mxcsr,
|
||||
RestoreFullFpuState: false);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,442 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace SharpEmu.HLE;
|
||||
|
||||
/// <summary>
|
||||
/// Process-wide registry of ELF PT_TLS templates and per-thread dynamic thread
|
||||
/// vectors. AMD64 uses TLS Variant II: startup/static module blocks precede the
|
||||
/// thread pointer, while modules introduced after a thread was initialized are
|
||||
/// represented by separately allocated DTV entries.
|
||||
/// </summary>
|
||||
public static class GuestTlsTemplate
|
||||
{
|
||||
// Must match CpuDispatcher/DirectExecutionBackend's mapped prefix. PS5
|
||||
// modules can require more than one host page of Variant II static TLS;
|
||||
// Dreaming Sarah's startup image, for example, reaches 0x1870 bytes.
|
||||
public const ulong StartupStaticTlsReservation = 0x10000UL;
|
||||
private static readonly object _gate = new();
|
||||
private static readonly SortedDictionary<ulong, ModuleTemplate> _modules = new();
|
||||
private static readonly Dictionary<ulong, ThreadDtv> _threadDtvs = new();
|
||||
private static ulong _staticTlsSize;
|
||||
private static ulong _maximumAlignment = 1;
|
||||
private static ulong _generation;
|
||||
|
||||
static GuestTlsTemplate()
|
||||
{
|
||||
RunTlsLayoutSelfChecks();
|
||||
}
|
||||
|
||||
private sealed class ModuleTemplate
|
||||
{
|
||||
public required ulong ModuleId { get; init; }
|
||||
public required byte[] InitImage { get; init; }
|
||||
public required ulong MemorySize { get; init; }
|
||||
public required ulong Alignment { get; init; }
|
||||
public required ulong AlignmentBias { get; init; }
|
||||
public required ulong StaticOffset { get; init; }
|
||||
}
|
||||
|
||||
private sealed class ThreadDtv
|
||||
{
|
||||
public ulong Generation { get; set; }
|
||||
public Dictionary<ulong, DtvEntry> Entries { get; } = new();
|
||||
public nint DtvAllocationBase { get; set; }
|
||||
public ulong DtvAddress { get; set; }
|
||||
}
|
||||
|
||||
private sealed class DtvEntry
|
||||
{
|
||||
public required ulong Address { get; init; }
|
||||
public nint AllocationBase { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>Main executable's initialized PT_TLS bytes.</summary>
|
||||
public static byte[] InitImage
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return _modules.TryGetValue(1, out var module)
|
||||
? (byte[])module.InitImage.Clone()
|
||||
: [];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Aligned size of the main executable's static TLS block.</summary>
|
||||
public static ulong BlockSize
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return _modules.TryGetValue(1, out var module)
|
||||
? module.StaticOffset
|
||||
: 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Main executable's PT_TLS alignment.</summary>
|
||||
public static ulong Alignment
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return _modules.TryGetValue(1, out var module)
|
||||
? module.Alignment
|
||||
: 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Total Variant II static TLS span required below the TCB.</summary>
|
||||
public static ulong StaticTlsSize
|
||||
{
|
||||
get { lock (_gate) { return _staticTlsSize; } }
|
||||
}
|
||||
|
||||
/// <summary>Largest PT_TLS alignment required by the registered modules.</summary>
|
||||
public static ulong MaximumAlignment
|
||||
{
|
||||
get { lock (_gate) { return _maximumAlignment; } }
|
||||
}
|
||||
|
||||
/// <summary>Current DTV generation, incremented for every registered module.</summary>
|
||||
public static ulong Generation
|
||||
{
|
||||
get { lock (_gate) { return _generation; } }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Backwards-compatible main-module registration entry point.
|
||||
/// </summary>
|
||||
public static void Set(ReadOnlySpan<byte> initImage, ulong memorySize, ulong alignment)
|
||||
{
|
||||
Reset();
|
||||
RegisterModule(1, initImage, memorySize, alignment, alignmentBias: 0);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Registers one module's PT_TLS template and allocates its Variant II
|
||||
/// static offset. Modules must be registered in loader module-ID order.
|
||||
/// </summary>
|
||||
public static ulong RegisterModule(
|
||||
ulong moduleId,
|
||||
ReadOnlySpan<byte> initImage,
|
||||
ulong memorySize,
|
||||
ulong alignment,
|
||||
ulong alignmentBias = 0)
|
||||
{
|
||||
if (moduleId == 0)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException(nameof(moduleId));
|
||||
}
|
||||
|
||||
var normalizedAlignment = alignment == 0 ? 1 : alignment;
|
||||
if ((normalizedAlignment & (normalizedAlignment - 1)) != 0)
|
||||
{
|
||||
throw new InvalidDataException($"PT_TLS alignment 0x{alignment:X} is not a power of two.");
|
||||
}
|
||||
if (memorySize > int.MaxValue || (ulong)initImage.Length > memorySize)
|
||||
{
|
||||
throw new InvalidDataException("PT_TLS template size is invalid or exceeds the supported process limit.");
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (_modules.TryGetValue(moduleId, out var existing))
|
||||
{
|
||||
if (existing.MemorySize != memorySize ||
|
||||
existing.Alignment != normalizedAlignment ||
|
||||
existing.AlignmentBias != alignmentBias ||
|
||||
!existing.InitImage.AsSpan().SequenceEqual(initImage))
|
||||
{
|
||||
throw new InvalidOperationException($"TLS module {moduleId} was registered with a different template.");
|
||||
}
|
||||
|
||||
return existing.StaticOffset;
|
||||
}
|
||||
|
||||
// FreeBSD/AMD64 Variant II: choose the smallest offset satisfying
|
||||
// offset - previous >= size and (-offset) % align == p_vaddr % align.
|
||||
var staticOffset = CalculateStaticOffset(
|
||||
_staticTlsSize,
|
||||
memorySize,
|
||||
normalizedAlignment,
|
||||
alignmentBias);
|
||||
if (staticOffset > StartupStaticTlsReservation)
|
||||
{
|
||||
throw new InvalidOperationException(
|
||||
$"Static TLS requires 0x{staticOffset:X} bytes, but startup maps only " +
|
||||
$"0x{StartupStaticTlsReservation:X} bytes below the thread pointer.");
|
||||
}
|
||||
_modules.Add(moduleId, new ModuleTemplate
|
||||
{
|
||||
ModuleId = moduleId,
|
||||
InitImage = initImage.ToArray(),
|
||||
MemorySize = memorySize,
|
||||
Alignment = normalizedAlignment,
|
||||
AlignmentBias = alignmentBias,
|
||||
StaticOffset = staticOffset,
|
||||
});
|
||||
_staticTlsSize = staticOffset;
|
||||
_maximumAlignment = Math.Max(_maximumAlignment, normalizedAlignment);
|
||||
_generation++;
|
||||
return staticOffset;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Returns the static TP-relative block offset for a module.</summary>
|
||||
public static bool TryGetStaticOffset(ulong moduleId, out ulong staticOffset)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (_modules.TryGetValue(moduleId, out var module))
|
||||
{
|
||||
staticOffset = module.StaticOffset;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
staticOffset = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>Clears all module templates and frees dynamic DTV blocks.</summary>
|
||||
public static void Reset()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
foreach (var dtv in _threadDtvs.Values)
|
||||
{
|
||||
FreeDynamicEntries(dtv);
|
||||
}
|
||||
|
||||
_threadDtvs.Clear();
|
||||
_modules.Clear();
|
||||
_staticTlsSize = 0;
|
||||
_maximumAlignment = 1;
|
||||
_generation++;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes every currently registered startup TLS block for a thread
|
||||
/// and records their addresses in that thread's DTV.
|
||||
/// </summary>
|
||||
public static void SeedThreadBlock(CpuContext context, ulong threadPointer)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(context);
|
||||
if (threadPointer == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (_threadDtvs.Remove(threadPointer, out var oldDtv))
|
||||
{
|
||||
FreeDynamicEntries(oldDtv);
|
||||
}
|
||||
|
||||
var dtv = new ThreadDtv();
|
||||
_threadDtvs.Add(threadPointer, dtv);
|
||||
foreach (var module in _modules.Values)
|
||||
{
|
||||
dtv.Entries[module.ModuleId] = CreateStaticOrDynamicEntry(context, threadPointer, module);
|
||||
}
|
||||
RebuildGuestDtv(context, threadPointer, dtv);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Implements the DTV lookup used by <c>__tls_get_addr</c>. Unknown module
|
||||
/// IDs and offsets outside the module's TLS image are rejected with zero.
|
||||
/// </summary>
|
||||
public static ulong ResolveAddress(CpuContext context, ulong moduleId, ulong offset)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(context);
|
||||
if (context.FsBase == 0 || moduleId == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_modules.TryGetValue(moduleId, out var module) || offset >= module.MemorySize)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!_threadDtvs.TryGetValue(context.FsBase, out var dtv))
|
||||
{
|
||||
dtv = new ThreadDtv();
|
||||
_threadDtvs.Add(context.FsBase, dtv);
|
||||
foreach (var startupModule in _modules.Values)
|
||||
{
|
||||
dtv.Entries[startupModule.ModuleId] = CreateStaticOrDynamicEntry(context, context.FsBase, startupModule);
|
||||
}
|
||||
RebuildGuestDtv(context, context.FsBase, dtv);
|
||||
}
|
||||
|
||||
var entryAdded = false;
|
||||
if (!dtv.Entries.TryGetValue(moduleId, out var entry))
|
||||
{
|
||||
// This module appeared after the thread's startup TLS layout was
|
||||
// seeded. Model rtld's lazy DTV allocation instead of assuming
|
||||
// unused space exists below the already-live thread pointer.
|
||||
entry = CreateDynamicEntry(module);
|
||||
dtv.Entries.Add(moduleId, entry);
|
||||
entryAdded = true;
|
||||
}
|
||||
|
||||
if (entryAdded || dtv.Generation != _generation)
|
||||
{
|
||||
RebuildGuestDtv(context, context.FsBase, dtv);
|
||||
}
|
||||
|
||||
return checked(entry.Address + offset);
|
||||
}
|
||||
}
|
||||
|
||||
private static DtvEntry CreateStaticOrDynamicEntry(
|
||||
CpuContext context,
|
||||
ulong threadPointer,
|
||||
ModuleTemplate module)
|
||||
{
|
||||
if (threadPointer >= module.StaticOffset)
|
||||
{
|
||||
var address = threadPointer - module.StaticOffset;
|
||||
var zeroImage = module.MemorySize == 0 ? [] : new byte[(int)module.MemorySize];
|
||||
if ((zeroImage.Length == 0 || context.Memory.TryWrite(address, zeroImage)) &&
|
||||
(module.InitImage.Length == 0 || context.Memory.TryWrite(address, module.InitImage)))
|
||||
{
|
||||
return new DtvEntry { Address = address };
|
||||
}
|
||||
}
|
||||
|
||||
return CreateDynamicEntry(module);
|
||||
}
|
||||
|
||||
private static DtvEntry CreateDynamicEntry(ModuleTemplate module)
|
||||
{
|
||||
var size = Math.Max(1UL, module.MemorySize);
|
||||
var allocationSize = checked(size + module.Alignment - 1);
|
||||
if (allocationSize > int.MaxValue)
|
||||
{
|
||||
throw new OutOfMemoryException("TLS module allocation exceeds the supported host allocation size.");
|
||||
}
|
||||
|
||||
var allocationBase = Marshal.AllocHGlobal((int)allocationSize);
|
||||
var alignedAddress = AlignUp(unchecked((ulong)allocationBase), module.Alignment);
|
||||
Marshal.Copy(new byte[(int)size], 0, unchecked((nint)alignedAddress), (int)size);
|
||||
if (module.InitImage.Length != 0)
|
||||
{
|
||||
Marshal.Copy(module.InitImage, 0, unchecked((nint)alignedAddress), module.InitImage.Length);
|
||||
}
|
||||
|
||||
return new DtvEntry
|
||||
{
|
||||
Address = alignedAddress,
|
||||
AllocationBase = allocationBase,
|
||||
};
|
||||
}
|
||||
|
||||
private static void FreeDynamicEntries(ThreadDtv dtv)
|
||||
{
|
||||
foreach (var entry in dtv.Entries.Values)
|
||||
{
|
||||
if (entry.AllocationBase != 0)
|
||||
{
|
||||
Marshal.FreeHGlobal(entry.AllocationBase);
|
||||
}
|
||||
}
|
||||
if (dtv.DtvAllocationBase != 0)
|
||||
{
|
||||
Marshal.FreeHGlobal(dtv.DtvAllocationBase);
|
||||
dtv.DtvAllocationBase = 0;
|
||||
dtv.DtvAddress = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private static void RebuildGuestDtv(CpuContext context, ulong threadPointer, ThreadDtv dtv)
|
||||
{
|
||||
var maximumModuleId = _modules.Count == 0 ? 0UL : _modules.Keys.Max();
|
||||
var byteSize = checked(2UL * sizeof(ulong) + maximumModuleId * sizeof(ulong));
|
||||
if (byteSize > int.MaxValue)
|
||||
{
|
||||
throw new OutOfMemoryException("Guest DTV exceeds the supported host allocation size.");
|
||||
}
|
||||
|
||||
var newAllocation = Marshal.AllocHGlobal((int)Math.Max((ulong)sizeof(ulong) * 2, byteSize));
|
||||
var newAddress = unchecked((ulong)newAllocation);
|
||||
Marshal.Copy(new byte[(int)Math.Max((ulong)sizeof(ulong) * 2, byteSize)], 0, newAllocation, (int)Math.Max((ulong)sizeof(ulong) * 2, byteSize));
|
||||
Marshal.WriteInt64(newAllocation, 0, unchecked((long)_generation));
|
||||
Marshal.WriteInt64(newAllocation, sizeof(ulong), unchecked((long)maximumModuleId));
|
||||
foreach (var (moduleId, entry) in dtv.Entries)
|
||||
{
|
||||
var slotOffset = checked((int)(2UL * sizeof(ulong) + (moduleId - 1) * sizeof(ulong)));
|
||||
Marshal.WriteInt64(newAllocation, slotOffset, unchecked((long)entry.Address));
|
||||
}
|
||||
|
||||
if (!context.TryWriteUInt64(threadPointer + sizeof(ulong), newAddress))
|
||||
{
|
||||
Marshal.FreeHGlobal(newAllocation);
|
||||
throw new InvalidOperationException("Failed to install the guest DTV pointer in the thread control block.");
|
||||
}
|
||||
|
||||
if (dtv.DtvAllocationBase != 0)
|
||||
{
|
||||
Marshal.FreeHGlobal(dtv.DtvAllocationBase);
|
||||
}
|
||||
dtv.DtvAllocationBase = newAllocation;
|
||||
dtv.DtvAddress = newAddress;
|
||||
dtv.Generation = _generation;
|
||||
}
|
||||
|
||||
private static ulong AlignUp(ulong value, ulong alignment)
|
||||
{
|
||||
var mask = alignment - 1;
|
||||
return checked((value + mask) & ~mask);
|
||||
}
|
||||
|
||||
private static ulong CalculateStaticOffset(
|
||||
ulong previousOffset,
|
||||
ulong size,
|
||||
ulong alignment,
|
||||
ulong alignmentBias)
|
||||
{
|
||||
var result = checked(previousOffset + size + alignment - 1);
|
||||
return result - ((result + alignmentBias) & (alignment - 1));
|
||||
}
|
||||
|
||||
[Conditional("DEBUG")]
|
||||
private static void RunTlsLayoutSelfChecks()
|
||||
{
|
||||
var firstOffset = RegisterModule(1, [0x11, 0x22], 0x20, 0x10, 0);
|
||||
var secondOffset = RegisterModule(2, [0x7A], 0x18, 0x20, 8);
|
||||
Debug.Assert(firstOffset == 0x20, "First Variant II TLS offset is incorrect.");
|
||||
Debug.Assert(secondOffset >= firstOffset + 0x18, "TLS modules overlap in the static layout.");
|
||||
Debug.Assert((unchecked(0UL - secondOffset) & 0x1F) == 8, "PT_TLS virtual-address congruence was not preserved.");
|
||||
|
||||
var lateEntry = CreateDynamicEntry(_modules[2]);
|
||||
try
|
||||
{
|
||||
Debug.Assert(lateEntry.AllocationBase != 0, "A late TLS module did not receive a dynamic DTV block.");
|
||||
Debug.Assert(Marshal.ReadByte(unchecked((nint)lateEntry.Address)) == 0x7A, "Late-module tdata was not initialized.");
|
||||
Debug.Assert(Marshal.ReadByte(unchecked((nint)lateEntry.Address + 1)) == 0, "Late-module tbss was not zero initialized.");
|
||||
}
|
||||
finally
|
||||
{
|
||||
Marshal.FreeHGlobal(lateEntry.AllocationBase);
|
||||
Reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,7 +13,9 @@ public static class HleDataSymbols
|
||||
private const string LibcNeedFlagNid = "P330P3dFF68";
|
||||
private const string LibcInternalNeedFlagNid = "ZT4ODD2Ts9o";
|
||||
private const int ProgNameMaxBytes = 511;
|
||||
private const ulong StackChkGuardValue = 0xC0DEC0DECAFEBABEUL;
|
||||
// Terminator canaries reserve the low byte as NUL. Keep the process data
|
||||
// symbol and every per-thread TLS copy byte-for-byte identical.
|
||||
private const ulong StackChkGuardValue = 0xC0DEC0DECAFEBA00UL;
|
||||
|
||||
private static readonly object _gate = new();
|
||||
private static readonly nint _stackChkGuardAddress = Allocate(sizeof(ulong) * 2);
|
||||
|
||||
@@ -6,12 +6,11 @@ using System.Collections.Concurrent;
|
||||
namespace SharpEmu.HLE;
|
||||
|
||||
/// <summary>
|
||||
/// Runs work on the real process main thread. GLFW windowing must live on
|
||||
/// that thread on macOS (AppKit) and Linux (X11's single event queue), so the
|
||||
/// CLI moves emulation onto a worker thread, parks the main thread in
|
||||
/// <see cref="Pump"/>, and the video presenter posts its window loop here. On
|
||||
/// Windows <see cref="IsAvailable"/> stays false and the window keeps its own
|
||||
/// thread.
|
||||
/// Runs work on the real process main thread. macOS only allows AppKit (and
|
||||
/// therefore GLFW windowing) on that thread, so the CLI moves emulation onto
|
||||
/// a worker thread, parks the main thread in <see cref="Pump"/>, and the
|
||||
/// video presenter posts its window loop here. On other platforms
|
||||
/// <see cref="IsAvailable"/> stays false and nothing changes.
|
||||
/// </summary>
|
||||
public static class HostMainThread
|
||||
{
|
||||
|
||||
@@ -0,0 +1,498 @@
|
||||
// Copyright (C) 2026 SharpEmu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace SharpEmu.HLE;
|
||||
|
||||
/// <summary>
|
||||
/// Cross-platform host virtual memory API with Win32 semantics.
|
||||
/// On Windows this forwards directly to kernel32. On POSIX systems it is
|
||||
/// implemented over mmap/mprotect/munmap with a shadow region table that
|
||||
/// answers VirtualQuery-style questions and tracks page protections.
|
||||
/// POSIX anonymous mappings are demand-paged by the kernel, so Win32
|
||||
/// "reserve-only" regions are mapped as committed memory directly and
|
||||
/// commit requests become protection changes.
|
||||
/// </summary>
|
||||
public static unsafe class HostMemory
|
||||
{
|
||||
public const uint MEM_COMMIT = 0x1000;
|
||||
public const uint MEM_RESERVE = 0x2000;
|
||||
public const uint MEM_RELEASE = 0x8000;
|
||||
public const uint MEM_FREE_STATE = 0x10000;
|
||||
public const uint MEM_PRIVATE = 0x20000;
|
||||
|
||||
public const uint PAGE_NOACCESS = 0x01;
|
||||
public const uint PAGE_READONLY = 0x02;
|
||||
public const uint PAGE_READWRITE = 0x04;
|
||||
public const uint PAGE_EXECUTE = 0x10;
|
||||
public const uint PAGE_EXECUTE_READ = 0x20;
|
||||
public const uint PAGE_EXECUTE_READWRITE = 0x40;
|
||||
|
||||
private const ulong PageSize = 0x1000;
|
||||
|
||||
/// <summary>Win32 MEMORY_BASIC_INFORMATION (64-bit) layout.</summary>
|
||||
public struct BasicInfo
|
||||
{
|
||||
public ulong BaseAddress;
|
||||
public ulong AllocationBase;
|
||||
public uint AllocationProtect;
|
||||
public uint Alignment1;
|
||||
public ulong RegionSize;
|
||||
public uint State;
|
||||
public uint Protect;
|
||||
public uint Type;
|
||||
public uint Alignment2;
|
||||
}
|
||||
|
||||
public static void* Alloc(void* address, nuint size, uint allocationType, uint protect)
|
||||
{
|
||||
if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return Win32VirtualAlloc(address, size, allocationType, protect);
|
||||
}
|
||||
|
||||
return Posix.Alloc(address, size, allocationType, protect);
|
||||
}
|
||||
|
||||
public static bool Free(void* address, nuint size, uint freeType)
|
||||
{
|
||||
if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return Win32VirtualFree(address, size, freeType);
|
||||
}
|
||||
|
||||
return Posix.Free(address, size, freeType);
|
||||
}
|
||||
|
||||
public static bool Protect(void* address, nuint size, uint newProtect, out uint oldProtect)
|
||||
{
|
||||
if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return Win32VirtualProtect(address, size, newProtect, out oldProtect);
|
||||
}
|
||||
|
||||
return Posix.Protect(address, size, newProtect, out oldProtect);
|
||||
}
|
||||
|
||||
public static nuint Query(void* address, out BasicInfo info)
|
||||
{
|
||||
if (OperatingSystem.IsWindows())
|
||||
{
|
||||
return Win32VirtualQuery(address, out info, (nuint)sizeof(BasicInfo));
|
||||
}
|
||||
|
||||
return Posix.Query(address, out info);
|
||||
}
|
||||
|
||||
public static void FlushInstructionCache(void* address, nuint size)
|
||||
{
|
||||
if (OperatingSystem.IsWindows())
|
||||
{
|
||||
Win32FlushInstructionCache(Win32GetCurrentProcess(), address, size);
|
||||
return;
|
||||
}
|
||||
|
||||
// The emulator only executes x86-64 guest code, so a non-Windows host
|
||||
// is either x86-64 (including Rosetta 2 translation) with a coherent
|
||||
// instruction cache, or would need sys_icache_invalidate for a future
|
||||
// arm64 recompiler. Nothing to do today.
|
||||
}
|
||||
|
||||
[DllImport("kernel32.dll", EntryPoint = "VirtualAlloc", SetLastError = true)]
|
||||
private static extern void* Win32VirtualAlloc(void* lpAddress, nuint dwSize, uint flAllocationType, uint flProtect);
|
||||
|
||||
[DllImport("kernel32.dll", EntryPoint = "VirtualFree", SetLastError = true)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static extern bool Win32VirtualFree(void* lpAddress, nuint dwSize, uint dwFreeType);
|
||||
|
||||
[DllImport("kernel32.dll", EntryPoint = "VirtualProtect", SetLastError = true)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static extern bool Win32VirtualProtect(void* lpAddress, nuint dwSize, uint flNewProtect, out uint lpflOldProtect);
|
||||
|
||||
[DllImport("kernel32.dll", EntryPoint = "VirtualQuery")]
|
||||
private static extern nuint Win32VirtualQuery(void* lpAddress, out BasicInfo lpBuffer, nuint dwLength);
|
||||
|
||||
[DllImport("kernel32.dll", EntryPoint = "GetCurrentProcess")]
|
||||
private static extern void* Win32GetCurrentProcess();
|
||||
|
||||
[DllImport("kernel32.dll", EntryPoint = "FlushInstructionCache")]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
private static extern bool Win32FlushInstructionCache(void* hProcess, void* lpBaseAddress, nuint dwSize);
|
||||
|
||||
private static class Posix
|
||||
{
|
||||
private const int PROT_NONE = 0x0;
|
||||
private const int PROT_READ = 0x1;
|
||||
private const int PROT_WRITE = 0x2;
|
||||
private const int PROT_EXEC = 0x4;
|
||||
|
||||
private const int MAP_PRIVATE = 0x02;
|
||||
private const int MAP_FIXED = 0x10;
|
||||
private static readonly int MAP_ANON = OperatingSystem.IsMacOS() ? 0x1000 : 0x20;
|
||||
private static readonly int MAP_NORESERVE = OperatingSystem.IsMacOS() ? 0 : 0x4000;
|
||||
|
||||
// Linux-only: fail instead of clobbering an existing mapping.
|
||||
private const int MAP_FIXED_NOREPLACE = 0x100000;
|
||||
|
||||
private static readonly nint MAP_FAILED = -1;
|
||||
|
||||
private static readonly object Gate = new();
|
||||
private static readonly SortedList<ulong, Region> Regions = new();
|
||||
|
||||
private sealed class Region
|
||||
{
|
||||
public ulong Base;
|
||||
public ulong Size;
|
||||
public uint DefaultProtect;
|
||||
public Dictionary<ulong, uint>? PageProtects;
|
||||
|
||||
public ulong End => Base + Size;
|
||||
|
||||
public uint ProtectAt(ulong pageAddress)
|
||||
{
|
||||
if (PageProtects is not null && PageProtects.TryGetValue(pageAddress, out var overriden))
|
||||
{
|
||||
return overriden;
|
||||
}
|
||||
|
||||
return DefaultProtect;
|
||||
}
|
||||
}
|
||||
|
||||
public static void* Alloc(void* address, nuint size, uint allocationType, uint protect)
|
||||
{
|
||||
if (size == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
var alignedSize = AlignUp((ulong)size, PageSize);
|
||||
|
||||
lock (Gate)
|
||||
{
|
||||
if (allocationType == MEM_COMMIT && address != null &&
|
||||
TryFindRegionLocked((ulong)address, out var existing))
|
||||
{
|
||||
// Note: MEM_RESERVE requests that overlap an existing
|
||||
// region must fail like Win32 does; only a pure commit
|
||||
// may target pages inside a tracked mapping.
|
||||
// Commit inside an existing mapping: the pages are already
|
||||
// backed (demand paged), so only apply the protection.
|
||||
var start = AlignDown((ulong)address, PageSize);
|
||||
var end = Math.Min(existing.End, AlignUp((ulong)address + alignedSize, PageSize));
|
||||
if (end <= start)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (mprotect((nint)start, (nuint)(end - start), ToPosixProtect(protect)) != 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
SetProtectRangeLocked(existing, start, end - start, protect);
|
||||
return address;
|
||||
}
|
||||
|
||||
if ((allocationType & MEM_RESERVE) == 0)
|
||||
{
|
||||
// MEM_COMMIT alone outside any known region is invalid here.
|
||||
return null;
|
||||
}
|
||||
|
||||
var posixProtect = ToPosixProtect(protect);
|
||||
var flags = MAP_PRIVATE | MAP_ANON;
|
||||
if ((allocationType & MEM_COMMIT) == 0)
|
||||
{
|
||||
// Reserve-only: keep the requested protection so the region
|
||||
// is usable without a separate commit step, but tell the
|
||||
// kernel not to account swap for it where supported.
|
||||
flags |= MAP_NORESERVE;
|
||||
}
|
||||
|
||||
nint result;
|
||||
if (address != null)
|
||||
{
|
||||
// Win32 maps at exactly the requested address or fails
|
||||
// without touching existing mappings. Fail up front on
|
||||
// any overlap we track, then place the mapping: Linux
|
||||
// gets MAP_FIXED_NOREPLACE (fails cleanly on host
|
||||
// mappings too). Darwin lacks NOREPLACE and plain
|
||||
// MAP_FIXED would silently clobber untracked host
|
||||
// memory (dyld, the runtime's JIT heap, Rosetta), so
|
||||
// pass the address as a hint instead -- the kernel
|
||||
// honors it when the range is free and relocates the
|
||||
// mapping otherwise, which we treat as failure.
|
||||
if (OverlapsTrackedRegionLocked((ulong)address, alignedSize))
|
||||
{
|
||||
Trace($"exact overlap: addr=0x{(ulong)address:X16} size=0x{alignedSize:X}");
|
||||
return null;
|
||||
}
|
||||
|
||||
var exactFlags = OperatingSystem.IsMacOS() ? flags : flags | MAP_FIXED_NOREPLACE;
|
||||
result = mmap((nint)address, (nuint)alignedSize, posixProtect, exactFlags, -1, 0);
|
||||
if (result == MAP_FAILED || (ulong)result != (ulong)address)
|
||||
{
|
||||
Trace($"exact mmap failed: addr=0x{(ulong)address:X16} got=0x{(ulong)result:X16} size=0x{alignedSize:X} errno={Marshal.GetLastPInvokeError()}");
|
||||
if (result != MAP_FAILED)
|
||||
{
|
||||
munmap(result, (nuint)alignedSize);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result = mmap(0, (nuint)alignedSize, posixProtect, flags, -1, 0);
|
||||
if (result == MAP_FAILED)
|
||||
{
|
||||
Trace($"mmap failed: size=0x{alignedSize:X} errno={Marshal.GetLastPInvokeError()}");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
Regions[(ulong)result] = new Region
|
||||
{
|
||||
Base = (ulong)result,
|
||||
Size = alignedSize,
|
||||
DefaultProtect = protect
|
||||
};
|
||||
|
||||
return (void*)result;
|
||||
}
|
||||
}
|
||||
|
||||
public static bool Free(void* address, nuint size, uint freeType)
|
||||
{
|
||||
_ = size;
|
||||
_ = freeType;
|
||||
|
||||
lock (Gate)
|
||||
{
|
||||
if (!Regions.TryGetValue((ulong)address, out var region))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
Regions.Remove((ulong)address);
|
||||
return munmap((nint)address, (nuint)region.Size) == 0;
|
||||
}
|
||||
}
|
||||
|
||||
public static bool Protect(void* address, nuint size, uint newProtect, out uint oldProtect)
|
||||
{
|
||||
oldProtect = PAGE_NOACCESS;
|
||||
if (size == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
var start = AlignDown((ulong)address, PageSize);
|
||||
var end = AlignUp((ulong)address + size, PageSize);
|
||||
|
||||
lock (Gate)
|
||||
{
|
||||
if (!TryFindRegionLocked(start, out var region) || end > region.End)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
oldProtect = region.ProtectAt(start);
|
||||
if (mprotect((nint)start, (nuint)(end - start), ToPosixProtect(newProtect)) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
SetProtectRangeLocked(region, start, end - start, newProtect);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public static nuint Query(void* address, out BasicInfo info)
|
||||
{
|
||||
info = default;
|
||||
var pageAddress = AlignDown((ulong)address, PageSize);
|
||||
|
||||
lock (Gate)
|
||||
{
|
||||
if (TryFindRegionLocked(pageAddress, out var region))
|
||||
{
|
||||
// Win32 VirtualQuery reports a run of pages sharing the
|
||||
// same protection, so stop the run where it changes. Do
|
||||
// not walk the whole mapping page-by-page here: PS5 GPU
|
||||
// apertures can span hundreds of GiB, while protection
|
||||
// overrides are sparse. A tiny read inside such a mapping
|
||||
// otherwise performs tens of millions of dictionary
|
||||
// lookups before it can return.
|
||||
var pageProtects = region.PageProtects;
|
||||
uint protect;
|
||||
ulong runEnd;
|
||||
if (pageProtects is null || pageProtects.Count == 0)
|
||||
{
|
||||
protect = region.DefaultProtect;
|
||||
runEnd = region.End;
|
||||
}
|
||||
else if (pageProtects.TryGetValue(pageAddress, out protect))
|
||||
{
|
||||
runEnd = pageAddress + PageSize;
|
||||
while (runEnd < region.End &&
|
||||
pageProtects.TryGetValue(runEnd, out var nextProtect) &&
|
||||
nextProtect == protect)
|
||||
{
|
||||
runEnd += PageSize;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
protect = region.DefaultProtect;
|
||||
runEnd = region.End;
|
||||
foreach (var overrideAddress in pageProtects.Keys)
|
||||
{
|
||||
if (overrideAddress > pageAddress && overrideAddress < runEnd)
|
||||
{
|
||||
runEnd = overrideAddress;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
info.BaseAddress = pageAddress;
|
||||
info.AllocationBase = region.Base;
|
||||
info.AllocationProtect = region.DefaultProtect;
|
||||
info.RegionSize = runEnd - pageAddress;
|
||||
info.State = MEM_COMMIT;
|
||||
info.Protect = protect;
|
||||
info.Type = MEM_PRIVATE;
|
||||
return (nuint)sizeof(BasicInfo);
|
||||
}
|
||||
|
||||
// Untracked host memory (runtime heaps, stacks, libraries) is
|
||||
// reported as a free block reaching to the next tracked region
|
||||
// so scanning callers keep advancing.
|
||||
var nextBase = ulong.MaxValue;
|
||||
foreach (var regionBase in Regions.Keys)
|
||||
{
|
||||
if (regionBase > pageAddress)
|
||||
{
|
||||
nextBase = regionBase;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
info.BaseAddress = pageAddress;
|
||||
info.AllocationBase = 0;
|
||||
info.AllocationProtect = PAGE_NOACCESS;
|
||||
info.RegionSize = (nextBase == ulong.MaxValue ? pageAddress + PageSize : nextBase) - pageAddress;
|
||||
info.State = MEM_FREE_STATE;
|
||||
info.Protect = PAGE_NOACCESS;
|
||||
info.Type = 0;
|
||||
return (nuint)sizeof(BasicInfo);
|
||||
}
|
||||
}
|
||||
|
||||
private static bool OverlapsTrackedRegionLocked(ulong start, ulong size)
|
||||
{
|
||||
var end = start + size;
|
||||
foreach (var region in Regions.Values)
|
||||
{
|
||||
if (region.Base < end && start < region.End)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private static bool TryFindRegionLocked(ulong address, out Region region)
|
||||
{
|
||||
region = null!;
|
||||
var keys = Regions.Keys;
|
||||
var low = 0;
|
||||
var high = keys.Count - 1;
|
||||
Region? candidate = null;
|
||||
while (low <= high)
|
||||
{
|
||||
var middle = low + ((high - low) >> 1);
|
||||
var entry = Regions.Values[middle];
|
||||
if (entry.Base <= address)
|
||||
{
|
||||
candidate = entry;
|
||||
low = middle + 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
high = middle - 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (candidate is null || address >= candidate.End)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
region = candidate;
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void SetProtectRangeLocked(Region region, ulong start, ulong size, uint protect)
|
||||
{
|
||||
if (start == region.Base && size >= region.Size)
|
||||
{
|
||||
region.DefaultProtect = protect;
|
||||
region.PageProtects = null;
|
||||
return;
|
||||
}
|
||||
|
||||
region.PageProtects ??= new Dictionary<ulong, uint>();
|
||||
var end = start + size;
|
||||
for (var pageAddress = start; pageAddress < end; pageAddress += PageSize)
|
||||
{
|
||||
if (protect == region.DefaultProtect)
|
||||
{
|
||||
region.PageProtects.Remove(pageAddress);
|
||||
}
|
||||
else
|
||||
{
|
||||
region.PageProtects[pageAddress] = protect;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static int ToPosixProtect(uint win32Protect)
|
||||
{
|
||||
return win32Protect switch
|
||||
{
|
||||
PAGE_NOACCESS => PROT_NONE,
|
||||
PAGE_READONLY => PROT_READ,
|
||||
PAGE_READWRITE => PROT_READ | PROT_WRITE,
|
||||
PAGE_EXECUTE => PROT_READ | PROT_EXEC,
|
||||
PAGE_EXECUTE_READ => PROT_READ | PROT_EXEC,
|
||||
PAGE_EXECUTE_READWRITE => PROT_READ | PROT_WRITE | PROT_EXEC,
|
||||
_ => PROT_READ | PROT_WRITE
|
||||
};
|
||||
}
|
||||
|
||||
private static void Trace(string message)
|
||||
{
|
||||
if (string.Equals(Environment.GetEnvironmentVariable("SHARPEMU_LOG_VMEM"), "1", StringComparison.Ordinal))
|
||||
{
|
||||
Console.Error.WriteLine($"[HOSTMEM] {message}");
|
||||
}
|
||||
}
|
||||
|
||||
private static ulong AlignDown(ulong value, ulong alignment) => value & ~(alignment - 1);
|
||||
|
||||
private static ulong AlignUp(ulong value, ulong alignment) => checked((value + alignment - 1) & ~(alignment - 1));
|
||||
|
||||
[DllImport("libc", SetLastError = true)]
|
||||
private static extern nint mmap(nint addr, nuint length, int prot, int flags, int fd, long offset);
|
||||
|
||||
[DllImport("libc", SetLastError = true)]
|
||||
private static extern int munmap(nint addr, nuint length);
|
||||
|
||||
[DllImport("libc", SetLastError = true)]
|
||||
private static extern int mprotect(nint addr, nuint length, int prot);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user