Ryujinx/Ryujinx.HLE/HOS/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs

400 lines
12 KiB
C#
Raw Normal View History

Add a new JIT compiler for CPU code (#693) * Start of the ARMeilleure project * Refactoring around the old IRAdapter, now renamed to PreAllocator * Optimize the LowestBitSet method * Add CLZ support and fix CLS implementation * Add missing Equals and GetHashCode overrides on some structs, misc small tweaks * Implement the ByteSwap IR instruction, and some refactoring on the assembler * Implement the DivideUI IR instruction and fix 64-bits IDIV * Correct constant operand type on CSINC * Move division instructions implementation to InstEmitDiv * Fix destination type for the ConditionalSelect IR instruction * Implement UMULH and SMULH, with new IR instructions * Fix some issues with shift instructions * Fix constant types for BFM instructions * Fix up new tests using the new V128 struct * Update tests * Move DIV tests to a separate file * Add support for calls, and some instructions that depends on them * Start adding support for SIMD & FP types, along with some of the related ARM instructions * Fix some typos and the divide instruction with FP operands * Fix wrong method call on Clz_V * Implement ARM FP & SIMD move instructions, Saddlv_V, and misc. fixes * Implement SIMD logical instructions and more misc. fixes * Fix PSRAD x86 instruction encoding, TRN, UABD and UABDL implementations * Implement float conversion instruction, merge in LDj3SNuD fixes, and some other misc. fixes * Implement SIMD shift instruction and fix Dup_V * Add SCVTF and UCVTF (vector, fixed-point) variants to the opcode table * Fix check with tolerance on tester * Implement FP & SIMD comparison instructions, and some fixes * Update FCVT (Scalar) encoding on the table to support the Half-float variants * Support passing V128 structs, some cleanup on the register allocator, merge LDj3SNuD fixes * Use old memory access methods, made a start on SIMD memory insts support, some fixes * Fix float constant passed to functions, save and restore non-volatile XMM registers, other fixes * Fix arguments count with struct return values, other fixes * More instructions * Misc. fixes and integrate LDj3SNuD fixes * Update tests * Add a faster linear scan allocator, unwinding support on windows, and other changes * Update Ryujinx.HLE * Update Ryujinx.Graphics * Fix V128 return pointer passing, RCX is clobbered * Update Ryujinx.Tests * Update ITimeZoneService * Stop using GetFunctionPointer as that can't be called from native code, misc. fixes and tweaks * Use generic GetFunctionPointerForDelegate method and other tweaks * Some refactoring on the code generator, assert on invalid operations and use a separate enum for intrinsics * Remove some unused code on the assembler * Fix REX.W prefix regression on float conversion instructions, add some sort of profiler * Add hardware capability detection * Fix regression on Sha1h and revert Fcm** changes * Add SSE2-only paths on vector extract and insert, some refactoring on the pre-allocator * Fix silly mistake introduced on last commit on CpuId * Generate inline stack probes when the stack allocation is too large * Initial support for the System-V ABI * Support multiple destination operands * Fix SSE2 VectorInsert8 path, and other fixes * Change placement of XMM callee save and restore code to match other compilers * Rename Dest to Destination and Inst to Instruction * Fix a regression related to calls and the V128 type * Add an extra space on comments to match code style * Some refactoring * Fix vector insert FP32 SSE2 path * Port over the ARM32 instructions * Avoid memory protection races on JIT Cache * Another fix on VectorInsert FP32 (thanks to LDj3SNuD * Float operands don't need to use the same register when VEX is supported * Add a new register allocator, higher quality code for hot code (tier up), and other tweaks * Some nits, small improvements on the pre allocator * CpuThreadState is gone * Allow changing CPU emulators with a config entry * Add runtime identifiers on the ARMeilleure project * Allow switching between CPUs through a config entry (pt. 2) * Change win10-x64 to win-x64 on projects * Update the Ryujinx project to use ARMeilleure * Ensure that the selected register is valid on the hybrid allocator * Allow exiting on returns to 0 (should fix test regression) * Remove register assignments for most used variables on the hybrid allocator * Do not use fixed registers as spill temp * Add missing namespace and remove unneeded using * Address PR feedback * Fix types, etc * Enable AssumeStrictAbiCompliance by default * Ensure that Spill and Fill don't load or store any more than necessary
2019-08-08 18:56:22 +00:00
using ARMeilleure.Memory;
using Ryujinx.Common.Logging;
using Ryujinx.HLE.HOS.Kernel.Process;
using System;
using System.Collections.Concurrent;
using System.Text;
using System.Threading;
namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
{
class NvHostCtrlIoctl
{
private static ConcurrentDictionary<KProcess, NvHostCtrlUserCtx> _userCtxs;
private static bool _isProductionMode = true;
static NvHostCtrlIoctl()
{
_userCtxs = new ConcurrentDictionary<KProcess, NvHostCtrlUserCtx>();
if (Set.NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object productionModeSetting))
{
_isProductionMode = ((string)productionModeSetting) != "0"; // Default value is ""
}
}
public static int ProcessIoctl(ServiceCtx context, int cmd)
{
switch (cmd & 0xffff)
{
case 0x0014: return SyncptRead (context);
case 0x0015: return SyncptIncr (context);
case 0x0016: return SyncptWait (context);
case 0x0019: return SyncptWaitEx (context);
case 0x001a: return SyncptReadMax (context);
case 0x001b: return GetConfig (context);
case 0x001d: return EventWait (context);
case 0x001e: return EventWaitAsync(context);
case 0x001f: return EventRegister (context);
}
throw new NotImplementedException(cmd.ToString("x8"));
}
private static int SyncptRead(ServiceCtx context)
{
return SyncptReadMinOrMax(context, max: false);
}
private static int SyncptIncr(ServiceCtx context)
{
long inputPosition = context.Request.GetBufferType0x21().Position;
int id = context.Memory.ReadInt32(inputPosition);
if ((uint)id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
GetUserCtx(context).Syncpt.Increment(id);
return NvResult.Success;
}
private static int SyncptWait(ServiceCtx context)
{
return SyncptWait(context, extended: false);
}
private static int SyncptWaitEx(ServiceCtx context)
{
return SyncptWait(context, extended: true);
}
private static int SyncptReadMax(ServiceCtx context)
{
return SyncptReadMinOrMax(context, max: true);
}
private static int GetConfig(ServiceCtx context)
{
if (!_isProductionMode)
{
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
string domain = MemoryHelper.ReadAsciiString(context.Memory, inputPosition + 0, 0x41);
string name = MemoryHelper.ReadAsciiString(context.Memory, inputPosition + 0x41, 0x41);
if (Set.NxSettings.Settings.TryGetValue($"{domain}!{name}", out object nvSetting))
{
byte[] settingBuffer = new byte[0x101];
if (nvSetting is string stringValue)
{
if (stringValue.Length > 0x100)
{
Logger.PrintError(LogClass.ServiceNv, $"{domain}!{name} String value size is too big!");
}
else
{
settingBuffer = Encoding.ASCII.GetBytes(stringValue + "\0");
}
}
if (nvSetting is int intValue)
{
settingBuffer = BitConverter.GetBytes(intValue);
}
else if (nvSetting is bool boolValue)
{
settingBuffer[0] = boolValue ? (byte)1 : (byte)0;
}
else
{
throw new NotImplementedException(nvSetting.GetType().Name);
}
context.Memory.WriteBytes(outputPosition + 0x82, settingBuffer);
Logger.PrintDebug(LogClass.ServiceNv, $"Got setting {domain}!{name}");
}
return NvResult.Success;
}
return NvResult.NotAvailableInProduction;
}
private static int EventWait(ServiceCtx context)
{
return EventWait(context, async: false);
}
private static int EventWaitAsync(ServiceCtx context)
{
return EventWait(context, async: true);
}
private static int EventRegister(ServiceCtx context)
{
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
int eventId = context.Memory.ReadInt32(inputPosition);
Logger.PrintStub(LogClass.ServiceNv);
return NvResult.Success;
}
private static int SyncptReadMinOrMax(ServiceCtx context, bool max)
{
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostCtrlSyncptRead args = MemoryHelper.Read<NvHostCtrlSyncptRead>(context.Memory, inputPosition);
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
if (max)
{
args.Value = GetUserCtx(context).Syncpt.GetMax(args.Id);
}
else
{
args.Value = GetUserCtx(context).Syncpt.GetMin(args.Id);
}
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int SyncptWait(ServiceCtx context, bool extended)
{
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostCtrlSyncptWait args = MemoryHelper.Read<NvHostCtrlSyncptWait>(context.Memory, inputPosition);
NvHostSyncpt syncpt = GetUserCtx(context).Syncpt;
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
int result;
if (syncpt.MinCompare(args.Id, args.Thresh))
{
result = NvResult.Success;
}
else if (args.Timeout == 0)
{
result = NvResult.TryAgain;
}
else
{
Logger.PrintDebug(LogClass.ServiceNv, "Waiting syncpt with timeout of " + args.Timeout + "ms...");
using (ManualResetEvent waitEvent = new ManualResetEvent(false))
{
syncpt.AddWaiter(args.Thresh, waitEvent);
// Note: Negative (> INT_MAX) timeouts aren't valid on .NET,
// in this case we just use the maximum timeout possible.
int timeout = args.Timeout;
if (timeout < -1)
{
timeout = int.MaxValue;
}
if (timeout == -1)
{
waitEvent.WaitOne();
result = NvResult.Success;
}
else if (waitEvent.WaitOne(timeout))
{
result = NvResult.Success;
}
else
{
result = NvResult.TimedOut;
}
}
Logger.PrintDebug(LogClass.ServiceNv, "Resuming...");
}
if (extended)
{
context.Memory.WriteInt32(outputPosition + 0xc, syncpt.GetMin(args.Id));
}
return result;
}
private static int EventWait(ServiceCtx context, bool async)
{
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostCtrlSyncptWaitEx args = MemoryHelper.Read<NvHostCtrlSyncptWaitEx>(context.Memory, inputPosition);
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
void WriteArgs()
{
MemoryHelper.Write(context.Memory, outputPosition, args);
}
NvHostSyncpt syncpt = GetUserCtx(context).Syncpt;
if (syncpt.MinCompare(args.Id, args.Thresh))
{
args.Value = syncpt.GetMin(args.Id);
WriteArgs();
return NvResult.Success;
}
if (!async)
{
args.Value = 0;
}
if (args.Timeout == 0)
{
WriteArgs();
return NvResult.TryAgain;
}
NvHostEvent Event;
int result, eventIndex;
if (async)
{
eventIndex = args.Value;
if ((uint)eventIndex >= NvHostCtrlUserCtx.EventsCount)
{
return NvResult.InvalidInput;
}
Event = GetUserCtx(context).Events[eventIndex];
}
else
{
Event = GetFreeEvent(context, syncpt, args.Id, out eventIndex);
}
if (Event != null &&
(Event.State == NvHostEventState.Registered ||
Event.State == NvHostEventState.Free))
{
Event.Id = args.Id;
Event.Thresh = args.Thresh;
Event.State = NvHostEventState.Waiting;
if (!async)
{
args.Value = ((args.Id & 0xfff) << 16) | 0x10000000;
}
else
{
args.Value = args.Id << 4;
}
args.Value |= eventIndex;
result = NvResult.TryAgain;
}
else
{
result = NvResult.InvalidInput;
}
WriteArgs();
return result;
}
private static NvHostEvent GetFreeEvent(
ServiceCtx context,
NvHostSyncpt syncpt,
int id,
out int eventIndex)
{
NvHostEvent[] events = GetUserCtx(context).Events;
eventIndex = NvHostCtrlUserCtx.EventsCount;
int nullIndex = NvHostCtrlUserCtx.EventsCount;
for (int index = 0; index < NvHostCtrlUserCtx.EventsCount; index++)
{
NvHostEvent Event = events[index];
if (Event != null)
{
if (Event.State == NvHostEventState.Registered ||
Event.State == NvHostEventState.Free)
{
eventIndex = index;
if (Event.Id == id)
{
return Event;
}
}
}
else if (nullIndex == NvHostCtrlUserCtx.EventsCount)
{
nullIndex = index;
}
}
if (nullIndex < NvHostCtrlUserCtx.EventsCount)
{
eventIndex = nullIndex;
return events[nullIndex] = new NvHostEvent();
}
if (eventIndex < NvHostCtrlUserCtx.EventsCount)
{
return events[eventIndex];
}
return null;
}
public static NvHostCtrlUserCtx GetUserCtx(ServiceCtx context)
{
return _userCtxs.GetOrAdd(context.Process, (key) => new NvHostCtrlUserCtx());
}
public static void UnloadProcess(KProcess process)
{
_userCtxs.TryRemove(process, out _);
}
}
}