Mirrors/Ryujinx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Adjust naming conventions and general refactoring in HLE Project (#490)

Browse source 
* Rename enum fields

* Naming conventions

* Remove unneeded ".this"

* Remove unneeded semicolons

* Remove unused Usings

* Don't use var

* Remove unneeded enum underlying types

* Explicitly label class visibility

* Remove unneeded @ prefixes

* Remove unneeded commas

* Remove unneeded if expressions

* Method doesn't use unsafe code

* Remove unneeded casts

* Initialized objects don't need an empty constructor

* Remove settings from DotSettings

* Revert "Explicitly label class visibility"

This reverts commit ad5eb5787c.

* Small changes

* Revert external enum renaming

* Changes from feedback

* Remove unneeded property setters
This commit is contained in:
Alex Barney 2018-12-04 14:23:37 -06:00 • committed by gdkchan
parent c86aacde76
commit 85dbb9559a
299 changed files with 12268 additions and 12276 deletions
Download patch file Download diff file Expand all files Collapse all files

138
Ryujinx.HLE/HOS/Services/Nv/INvDrvServices.cs
View file

@ -14,15 +14,15 @@ namespace Ryujinx.HLE.HOS.Services.Nv
{
class INvDrvServices : IpcService
{
private delegate int IoctlProcessor(ServiceCtx Context, int Cmd);
private delegate int IoctlProcessor(ServiceCtx context, int cmd);
private Dictionary<int, ServiceProcessRequest> m_Commands;
private Dictionary<int, ServiceProcessRequest> _commands;
public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;
public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => _commands;
private static Dictionary<string, IoctlProcessor> IoctlProcessors =
new Dictionary<string, IoctlProcessor>()
{
private static Dictionary<string, IoctlProcessor> _ioctlProcessors =
new Dictionary<string, IoctlProcessor>
{
{ "/dev/nvhost-as-gpu", ProcessIoctlNvGpuAS },
{ "/dev/nvhost-ctrl", ProcessIoctlNvHostCtrl },
{ "/dev/nvhost-ctrl-gpu", ProcessIoctlNvGpuGpu },
@ -32,13 +32,13 @@ namespace Ryujinx.HLE.HOS.Services.Nv
{ "/dev/nvmap", ProcessIoctlNvMap }
};
public static GlobalStateTable Fds { get; private set; }
public static GlobalStateTable Fds { get; }
private KEvent Event;
private KEvent _event;
public INvDrvServices(Horizon System)
public INvDrvServices(Horizon system)
{
m_Commands = new Dictionary<int, ServiceProcessRequest>()
_commands = new Dictionary<int, ServiceProcessRequest>
{
{ 0, Open },
{ 1, Ioctl },
@ -50,7 +50,7 @@ namespace Ryujinx.HLE.HOS.Services.Nv
{ 13, FinishInitialize }
};
Event = new KEvent(System);
_event = new KEvent(system);
}
static INvDrvServices()
@ -58,166 +58,166 @@ namespace Ryujinx.HLE.HOS.Services.Nv
Fds = new GlobalStateTable();
}
public long Open(ServiceCtx Context)
public long Open(ServiceCtx context)
{
long NamePtr = Context.Request.SendBuff[0].Position;
long namePtr = context.Request.SendBuff[0].Position;
string Name = MemoryHelper.ReadAsciiString(Context.Memory, NamePtr);
string name = MemoryHelper.ReadAsciiString(context.Memory, namePtr);
int Fd = Fds.Add(Context.Process, new NvFd(Name));
int fd = Fds.Add(context.Process, new NvFd(name));
Context.ResponseData.Write(Fd);
Context.ResponseData.Write(0);
context.ResponseData.Write(fd);
context.ResponseData.Write(0);
return 0;
}
public long Ioctl(ServiceCtx Context)
public long Ioctl(ServiceCtx context)
{
int Fd = Context.RequestData.ReadInt32();
int Cmd = Context.RequestData.ReadInt32();
int fd = context.RequestData.ReadInt32();
int cmd = context.RequestData.ReadInt32();
NvFd FdData = Fds.GetData<NvFd>(Context.Process, Fd);
NvFd fdData = Fds.GetData<NvFd>(context.Process, fd);
int Result;
int result;
if (IoctlProcessors.TryGetValue(FdData.Name, out IoctlProcessor Process))
if (_ioctlProcessors.TryGetValue(fdData.Name, out IoctlProcessor process))
{
Result = Process(Context, Cmd);
result = process(context, cmd);
}
else
{
throw new NotImplementedException($"{FdData.Name} {Cmd:x4}");
throw new NotImplementedException($"{fdData.Name} {cmd:x4}");
}
//TODO: Verify if the error codes needs to be translated.
Context.ResponseData.Write(Result);
context.ResponseData.Write(result);
return 0;
}
public long Close(ServiceCtx Context)
public long Close(ServiceCtx context)
{
int Fd = Context.RequestData.ReadInt32();
int fd = context.RequestData.ReadInt32();
Fds.Delete(Context.Process, Fd);
Fds.Delete(context.Process, fd);
Context.ResponseData.Write(0);
context.ResponseData.Write(0);
return 0;
}
public long Initialize(ServiceCtx Context)
public long Initialize(ServiceCtx context)
{
long TransferMemSize = Context.RequestData.ReadInt64();
int TransferMemHandle = Context.Request.HandleDesc.ToCopy[0];
long transferMemSize = context.RequestData.ReadInt64();
int transferMemHandle = context.Request.HandleDesc.ToCopy[0];
NvMapIoctl.InitializeNvMap(Context);
NvMapIoctl.InitializeNvMap(context);
Context.ResponseData.Write(0);
context.ResponseData.Write(0);
return 0;
}
public long QueryEvent(ServiceCtx Context)
public long QueryEvent(ServiceCtx context)
{
int Fd = Context.RequestData.ReadInt32();
int EventId = Context.RequestData.ReadInt32();
int fd = context.RequestData.ReadInt32();
int eventId = context.RequestData.ReadInt32();
//TODO: Use Fd/EventId, different channels have different events.
if (Context.Process.HandleTable.GenerateHandle(Event.ReadableEvent, out int Handle) != KernelResult.Success)
if (context.Process.HandleTable.GenerateHandle(_event.ReadableEvent, out int handle) != KernelResult.Success)
{
throw new InvalidOperationException("Out of handles!");
}
Context.Response.HandleDesc = IpcHandleDesc.MakeCopy(Handle);
context.Response.HandleDesc = IpcHandleDesc.MakeCopy(handle);
Context.ResponseData.Write(0);
context.ResponseData.Write(0);
return 0;
}
public long SetClientPid(ServiceCtx Context)
public long SetClientPid(ServiceCtx context)
{
long Pid = Context.RequestData.ReadInt64();
long pid = context.RequestData.ReadInt64();
Context.ResponseData.Write(0);
context.ResponseData.Write(0);
return 0;
}
public long FinishInitialize(ServiceCtx Context)
public long FinishInitialize(ServiceCtx context)
{
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return 0;
}
private static int ProcessIoctlNvGpuAS(ServiceCtx Context, int Cmd)
private static int ProcessIoctlNvGpuAS(ServiceCtx context, int cmd)
{
return ProcessIoctl(Context, Cmd, NvGpuASIoctl.ProcessIoctl);
return ProcessIoctl(context, cmd, NvGpuASIoctl.ProcessIoctl);
}
private static int ProcessIoctlNvHostCtrl(ServiceCtx Context, int Cmd)
private static int ProcessIoctlNvHostCtrl(ServiceCtx context, int cmd)
{
return ProcessIoctl(Context, Cmd, NvHostCtrlIoctl.ProcessIoctl);
return ProcessIoctl(context, cmd, NvHostCtrlIoctl.ProcessIoctl);
}
private static int ProcessIoctlNvGpuGpu(ServiceCtx Context, int Cmd)
private static int ProcessIoctlNvGpuGpu(ServiceCtx context, int cmd)
{
return ProcessIoctl(Context, Cmd, NvGpuGpuIoctl.ProcessIoctl);
return ProcessIoctl(context, cmd, NvGpuGpuIoctl.ProcessIoctl);
}
private static int ProcessIoctlNvHostChannel(ServiceCtx Context, int Cmd)
private static int ProcessIoctlNvHostChannel(ServiceCtx context, int cmd)
{
return ProcessIoctl(Context, Cmd, NvHostChannelIoctl.ProcessIoctl);
return ProcessIoctl(context, cmd, NvHostChannelIoctl.ProcessIoctl);
}
private static int ProcessIoctlNvMap(ServiceCtx Context, int Cmd)
private static int ProcessIoctlNvMap(ServiceCtx context, int cmd)
{
return ProcessIoctl(Context, Cmd, NvMapIoctl.ProcessIoctl);
return ProcessIoctl(context, cmd, NvMapIoctl.ProcessIoctl);
}
private static int ProcessIoctl(ServiceCtx Context, int Cmd, IoctlProcessor Processor)
private static int ProcessIoctl(ServiceCtx context, int cmd, IoctlProcessor processor)
{
if (CmdIn(Cmd) && Context.Request.GetBufferType0x21().Position == 0)
if (CmdIn(cmd) && context.Request.GetBufferType0x21().Position == 0)
{
Logger.PrintError(LogClass.ServiceNv, "Input buffer is null!");
return NvResult.InvalidInput;
}
if (CmdOut(Cmd) && Context.Request.GetBufferType0x22().Position == 0)
if (CmdOut(cmd) && context.Request.GetBufferType0x22().Position == 0)
{
Logger.PrintError(LogClass.ServiceNv, "Output buffer is null!");
return NvResult.InvalidInput;
}
return Processor(Context, Cmd);
return processor(context, cmd);
}
private static bool CmdIn(int Cmd)
private static bool CmdIn(int cmd)
{
return ((Cmd >> 30) & 1) != 0;
return ((cmd >> 30) & 1) != 0;
}
private static bool CmdOut(int Cmd)
private static bool CmdOut(int cmd)
{
return ((Cmd >> 31) & 1) != 0;
return ((cmd >> 31) & 1) != 0;
}
public static void UnloadProcess(KProcess Process)
public static void UnloadProcess(KProcess process)
{
Fds.DeleteProcess(Process);
Fds.DeleteProcess(process);
NvGpuASIoctl.UnloadProcess(Process);
NvGpuASIoctl.UnloadProcess(process);
NvHostChannelIoctl.UnloadProcess(Process);
NvHostChannelIoctl.UnloadProcess(process);
NvHostCtrlIoctl.UnloadProcess(Process);
NvHostCtrlIoctl.UnloadProcess(process);
NvMapIoctl.UnloadProcess(Process);
NvMapIoctl.UnloadProcess(process);
}
}
}

6
Ryujinx.HLE/HOS/Services/Nv/NvFd.cs
View file

@ -2,11 +2,11 @@ namespace Ryujinx.HLE.HOS.Services.Nv
{
class NvFd
{
public string Name { get; private set; }
public string Name { get; }
public NvFd(string Name)
public NvFd(string name)
{
this.Name = Name;
Name = name;
}
}
}

146
Ryujinx.HLE/HOS/Services/Nv/NvGpuAS/NvGpuASCtx.cs
View file

@ -5,73 +5,73 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
{
class NvGpuASCtx
{
public NvGpuVmm Vmm { get; private set; }
public NvGpuVmm Vmm { get; }
private class Range
{
public ulong Start { get; private set; }
public ulong End { get; private set; }
public ulong Start { get; }
public ulong End { get; }
public Range(long Position, long Size)
public Range(long position, long size)
{
Start = (ulong)Position;
End = (ulong)Size + Start;
Start = (ulong)position;
End = (ulong)size + Start;
}
}
private class MappedMemory : Range
{
public long PhysicalAddress { get; private set; }
public bool VaAllocated { get; private set; }
public long PhysicalAddress { get; }
public bool VaAllocated { get; }
public MappedMemory(
long Position,
long Size,
long PhysicalAddress,
bool VaAllocated) : base(Position, Size)
long position,
long size,
long physicalAddress,
bool vaAllocated) : base(position, size)
{
this.PhysicalAddress = PhysicalAddress;
this.VaAllocated = VaAllocated;
PhysicalAddress = physicalAddress;
VaAllocated = vaAllocated;
}
}
private SortedList<long, Range> Maps;
private SortedList<long, Range> Reservations;
private SortedList<long, Range> _maps;
private SortedList<long, Range> _reservations;
public NvGpuASCtx(ServiceCtx Context)
public NvGpuASCtx(ServiceCtx context)
{
Vmm = new NvGpuVmm(Context.Memory);
Vmm = new NvGpuVmm(context.Memory);
Maps = new SortedList<long, Range>();
Reservations = new SortedList<long, Range>();
_maps = new SortedList<long, Range>();
_reservations = new SortedList<long, Range>();
}
public bool ValidateFixedBuffer(long Position, long Size)
public bool ValidateFixedBuffer(long position, long size)
{
long MapEnd = Position + Size;
long mapEnd = position + size;
//Check if size is valid (0 is also not allowed).
if ((ulong)MapEnd <= (ulong)Position)
if ((ulong)mapEnd <= (ulong)position)
{
return false;
}
//Check if address is page aligned.
if ((Position & NvGpuVmm.PageMask) != 0)
if ((position & NvGpuVmm.PageMask) != 0)
{
return false;
}
//Check if region is reserved.
if (BinarySearch(Reservations, Position) == null)
if (BinarySearch(_reservations, position) == null)
{
return false;
}
//Check for overlap with already mapped buffers.
Range Map = BinarySearchLt(Maps, MapEnd);
Range map = BinarySearchLt(_maps, mapEnd);
if (Map != null && Map.End > (ulong)Position)
if (map != null && map.End > (ulong)position)
{
return false;
}
@ -80,25 +80,25 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
}
public void AddMap(
long Position,
long Size,
long PhysicalAddress,
bool VaAllocated)
long position,
long size,
long physicalAddress,
bool vaAllocated)
{
Maps.Add(Position, new MappedMemory(Position, Size, PhysicalAddress, VaAllocated));
_maps.Add(position, new MappedMemory(position, size, physicalAddress, vaAllocated));
}
public bool RemoveMap(long Position, out long Size)
public bool RemoveMap(long position, out long size)
{
Size = 0;
size = 0;
if (Maps.Remove(Position, out Range Value))
if (_maps.Remove(position, out Range value))
{
MappedMemory Map = (MappedMemory)Value;
MappedMemory map = (MappedMemory)value;
if (Map.VaAllocated)
if (map.VaAllocated)
{
Size = (long)(Map.End - Map.Start);
size = (long)(map.End - map.Start);
}
return true;
@ -107,94 +107,94 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
return false;
}
public bool TryGetMapPhysicalAddress(long Position, out long PhysicalAddress)
public bool TryGetMapPhysicalAddress(long position, out long physicalAddress)
{
Range Map = BinarySearch(Maps, Position);
Range map = BinarySearch(_maps, position);
if (Map != null)
if (map != null)
{
PhysicalAddress = ((MappedMemory)Map).PhysicalAddress;
physicalAddress = ((MappedMemory)map).PhysicalAddress;
return true;
}
PhysicalAddress = 0;
physicalAddress = 0;
return false;
}
public void AddReservation(long Position, long Size)
public void AddReservation(long position, long size)
{
Reservations.Add(Position, new Range(Position, Size));
_reservations.Add(position, new Range(position, size));
}
public bool RemoveReservation(long Position)
public bool RemoveReservation(long position)
{
return Reservations.Remove(Position);
return _reservations.Remove(position);
}
private Range BinarySearch(SortedList<long, Range> Lst, long Position)
private Range BinarySearch(SortedList<long, Range> lst, long position)
{
int Left = 0;
int Right = Lst.Count - 1;
int left = 0;
int right = lst.Count - 1;
while (Left <= Right)
while (left <= right)
{
int Size = Right - Left;
int size = right - left;
int Middle = Left + (Size >> 1);
int middle = left + (size >> 1);
Range Rg = Lst.Values[Middle];
Range rg = lst.Values[middle];
if ((ulong)Position >= Rg.Start && (ulong)Position < Rg.End)
if ((ulong)position >= rg.Start && (ulong)position < rg.End)
{
return Rg;
return rg;
}
if ((ulong)Position < Rg.Start)
if ((ulong)position < rg.Start)
{
Right = Middle - 1;
right = middle - 1;
}
else
{
Left = Middle + 1;
left = middle + 1;
}
}
return null;
}
private Range BinarySearchLt(SortedList<long, Range> Lst, long Position)
private Range BinarySearchLt(SortedList<long, Range> lst, long position)
{
Range LtRg = null;
Range ltRg = null;
int Left = 0;
int Right = Lst.Count - 1;
int left = 0;
int right = lst.Count - 1;
while (Left <= Right)
while (left <= right)
{
int Size = Right - Left;
int size = right - left;
int Middle = Left + (Size >> 1);
int middle = left + (size >> 1);
Range Rg = Lst.Values[Middle];
Range rg = lst.Values[middle];
if ((ulong)Position < Rg.Start)
if ((ulong)position < rg.Start)
{
Right = Middle - 1;
right = middle - 1;
}
else
{
Left = Middle + 1;
left = middle + 1;
if ((ulong)Position > Rg.Start)
if ((ulong)position > rg.Start)
{
LtRg = Rg;
ltRg = rg;
}
}
}
return LtRg;
return ltRg;
}
}
}

244
Ryujinx.HLE/HOS/Services/Nv/NvGpuAS/NvGpuASIoctl.cs
View file

@ -14,182 +14,182 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
private const int FlagRemapSubRange = 0x100;
private static ConcurrentDictionary<KProcess, NvGpuASCtx> ASCtxs;
private static ConcurrentDictionary<KProcess, NvGpuASCtx> _asCtxs;
static NvGpuASIoctl()
{
ASCtxs = new ConcurrentDictionary<KProcess, NvGpuASCtx>();
_asCtxs = new ConcurrentDictionary<KProcess, NvGpuASCtx>();
}
public static int ProcessIoctl(ServiceCtx Context, int Cmd)
public static int ProcessIoctl(ServiceCtx context, int cmd)
{
switch (Cmd & 0xffff)
switch (cmd & 0xffff)
{
case 0x4101: return BindChannel (Context);
case 0x4102: return AllocSpace (Context);
case 0x4103: return FreeSpace (Context);
case 0x4105: return UnmapBuffer (Context);
case 0x4106: return MapBufferEx (Context);
case 0x4108: return GetVaRegions(Context);
case 0x4109: return InitializeEx(Context);
case 0x4114: return Remap (Context, Cmd);
case 0x4101: return BindChannel (context);
case 0x4102: return AllocSpace (context);
case 0x4103: return FreeSpace (context);
case 0x4105: return UnmapBuffer (context);
case 0x4106: return MapBufferEx (context);
case 0x4108: return GetVaRegions(context);
case 0x4109: return InitializeEx(context);
case 0x4114: return Remap (context, cmd);
}
throw new NotImplementedException(Cmd.ToString("x8"));
throw new NotImplementedException(cmd.ToString("x8"));
}
private static int BindChannel(ServiceCtx Context)
private static int BindChannel(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int AllocSpace(ServiceCtx Context)
private static int AllocSpace(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuASAllocSpace Args = MemoryHelper.Read<NvGpuASAllocSpace>(Context.Memory, InputPosition);
NvGpuASAllocSpace args = MemoryHelper.Read<NvGpuASAllocSpace>(context.Memory, inputPosition);
NvGpuASCtx ASCtx = GetASCtx(Context);
NvGpuASCtx asCtx = GetASCtx(context);
ulong Size = (ulong)Args.Pages *
(ulong)Args.PageSize;
ulong size = (ulong)args.Pages *
(ulong)args.PageSize;
int Result = NvResult.Success;
int result = NvResult.Success;
lock (ASCtx)
lock (asCtx)
{
//Note: When the fixed offset flag is not set,
//the Offset field holds the alignment size instead.
if ((Args.Flags & FlagFixedOffset) != 0)
if ((args.Flags & FlagFixedOffset) != 0)
{
Args.Offset = ASCtx.Vmm.ReserveFixed(Args.Offset, (long)Size);
args.Offset = asCtx.Vmm.ReserveFixed(args.Offset, (long)size);
}
else
{
Args.Offset = ASCtx.Vmm.Reserve((long)Size, Args.Offset);
args.Offset = asCtx.Vmm.Reserve((long)size, args.Offset);
}
if (Args.Offset < 0)
if (args.Offset < 0)
{
Args.Offset = 0;
args.Offset = 0;
Logger.PrintWarning(LogClass.ServiceNv, $"Failed to allocate size {Size:x16}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Failed to allocate size {size:x16}!");
Result = NvResult.OutOfMemory;
result = NvResult.OutOfMemory;
}
else
{
ASCtx.AddReservation(Args.Offset, (long)Size);
asCtx.AddReservation(args.Offset, (long)size);
}
}
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return Result;
return result;
}
private static int FreeSpace(ServiceCtx Context)
private static int FreeSpace(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuASAllocSpace Args = MemoryHelper.Read<NvGpuASAllocSpace>(Context.Memory, InputPosition);
NvGpuASAllocSpace args = MemoryHelper.Read<NvGpuASAllocSpace>(context.Memory, inputPosition);
NvGpuASCtx ASCtx = GetASCtx(Context);
NvGpuASCtx asCtx = GetASCtx(context);
int Result = NvResult.Success;
int result = NvResult.Success;
lock (ASCtx)
lock (asCtx)
{
ulong Size = (ulong)Args.Pages *
(ulong)Args.PageSize;
ulong size = (ulong)args.Pages *
(ulong)args.PageSize;
if (ASCtx.RemoveReservation(Args.Offset))
if (asCtx.RemoveReservation(args.Offset))
{
ASCtx.Vmm.Free(Args.Offset, (long)Size);
asCtx.Vmm.Free(args.Offset, (long)size);
}
else
{
Logger.PrintWarning(LogClass.ServiceNv,
$"Failed to free offset 0x{Args.Offset:x16} size 0x{Size:x16}!");
$"Failed to free offset 0x{args.Offset:x16} size 0x{size:x16}!");
Result = NvResult.InvalidInput;
result = NvResult.InvalidInput;
}
}
return Result;
return result;
}
private static int UnmapBuffer(ServiceCtx Context)
private static int UnmapBuffer(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuASUnmapBuffer Args = MemoryHelper.Read<NvGpuASUnmapBuffer>(Context.Memory, InputPosition);
NvGpuASUnmapBuffer args = MemoryHelper.Read<NvGpuASUnmapBuffer>(context.Memory, inputPosition);
NvGpuASCtx ASCtx = GetASCtx(Context);
NvGpuASCtx asCtx = GetASCtx(context);
lock (ASCtx)
lock (asCtx)
{
if (ASCtx.RemoveMap(Args.Offset, out long Size))
if (asCtx.RemoveMap(args.Offset, out long size))
{
if (Size != 0)
if (size != 0)
{
ASCtx.Vmm.Free(Args.Offset, Size);
asCtx.Vmm.Free(args.Offset, size);
}
}
else
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid buffer offset {Args.Offset:x16}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid buffer offset {args.Offset:x16}!");
}
}
return NvResult.Success;
}
private static int MapBufferEx(ServiceCtx Context)
private static int MapBufferEx(ServiceCtx context)
{
const string MapErrorMsg = "Failed to map fixed buffer with offset 0x{0:x16} and size 0x{1:x16}!";
const string mapErrorMsg = "Failed to map fixed buffer with offset 0x{0:x16} and size 0x{1:x16}!";
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuASMapBufferEx Args = MemoryHelper.Read<NvGpuASMapBufferEx>(Context.Memory, InputPosition);
NvGpuASMapBufferEx args = MemoryHelper.Read<NvGpuASMapBufferEx>(context.Memory, inputPosition);
NvGpuASCtx ASCtx = GetASCtx(Context);
NvGpuASCtx asCtx = GetASCtx(context);
NvMapHandle Map = NvMapIoctl.GetNvMapWithFb(Context, Args.NvMapHandle);
NvMapHandle map = NvMapIoctl.GetNvMapWithFb(context, args.NvMapHandle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid NvMap handle 0x{Args.NvMapHandle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid NvMap handle 0x{args.NvMapHandle:x8}!");
return NvResult.InvalidInput;
}
long PA;
long pa;
if ((Args.Flags & FlagRemapSubRange) != 0)
if ((args.Flags & FlagRemapSubRange) != 0)
{
lock (ASCtx)
lock (asCtx)
{
if (ASCtx.TryGetMapPhysicalAddress(Args.Offset, out PA))
if (asCtx.TryGetMapPhysicalAddress(args.Offset, out pa))
{
long VA = Args.Offset + Args.BufferOffset;
long va = args.Offset + args.BufferOffset;
PA += Args.BufferOffset;
pa += args.BufferOffset;
if (ASCtx.Vmm.Map(PA, VA, Args.MappingSize) < 0)
if (asCtx.Vmm.Map(pa, va, args.MappingSize) < 0)
{
string Msg = string.Format(MapErrorMsg, VA, Args.MappingSize);
string msg = string.Format(mapErrorMsg, va, args.MappingSize);
Logger.PrintWarning(LogClass.ServiceNv, Msg);
Logger.PrintWarning(LogClass.ServiceNv, msg);
return NvResult.InvalidInput;
}
@ -198,117 +198,117 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
}
else
{
Logger.PrintWarning(LogClass.ServiceNv, $"Address 0x{Args.Offset:x16} not mapped!");
Logger.PrintWarning(LogClass.ServiceNv, $"Address 0x{args.Offset:x16} not mapped!");
return NvResult.InvalidInput;
}
}
}
PA = Map.Address + Args.BufferOffset;
pa = map.Address + args.BufferOffset;
long Size = Args.MappingSize;
long size = args.MappingSize;
if (Size == 0)
if (size == 0)
{
Size = (uint)Map.Size;
size = (uint)map.Size;
}
int Result = NvResult.Success;
int result = NvResult.Success;
lock (ASCtx)
lock (asCtx)
{
//Note: When the fixed offset flag is not set,
//the Offset field holds the alignment size instead.
bool VaAllocated = (Args.Flags & FlagFixedOffset) == 0;
bool vaAllocated = (args.Flags & FlagFixedOffset) == 0;
if (!VaAllocated)
if (!vaAllocated)
{
if (ASCtx.ValidateFixedBuffer(Args.Offset, Size))
if (asCtx.ValidateFixedBuffer(args.Offset, size))
{
Args.Offset = ASCtx.Vmm.Map(PA, Args.Offset, Size);
args.Offset = asCtx.Vmm.Map(pa, args.Offset, size);
}
else
{
string Msg = string.Format(MapErrorMsg, Args.Offset, Size);
string msg = string.Format(mapErrorMsg, args.Offset, size);
Logger.PrintWarning(LogClass.ServiceNv, Msg);
Logger.PrintWarning(LogClass.ServiceNv, msg);
Result = NvResult.InvalidInput;
result = NvResult.InvalidInput;
}
}
else
{
Args.Offset = ASCtx.Vmm.Map(PA, Size);
args.Offset = asCtx.Vmm.Map(pa, size);
}
if (Args.Offset < 0)
if (args.Offset < 0)
{
Args.Offset = 0;
args.Offset = 0;
Logger.PrintWarning(LogClass.ServiceNv, $"Failed to map size 0x{Size:x16}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Failed to map size 0x{size:x16}!");
Result = NvResult.InvalidInput;
result = NvResult.InvalidInput;
}
else
{
ASCtx.AddMap(Args.Offset, Size, PA, VaAllocated);
asCtx.AddMap(args.Offset, size, pa, vaAllocated);
}
}
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return Result;
return result;
}
private static int GetVaRegions(ServiceCtx Context)
private static int GetVaRegions(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int InitializeEx(ServiceCtx Context)
private static int InitializeEx(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int Remap(ServiceCtx Context, int Cmd)
private static int Remap(ServiceCtx context, int cmd)
{
int Count = ((Cmd >> 16) & 0xff) / 0x14;
int count = ((cmd >> 16) & 0xff) / 0x14;
long InputPosition = Context.Request.GetBufferType0x21().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
for (int Index = 0; Index < Count; Index++, InputPosition += 0x14)
for (int index = 0; index < count; index++, inputPosition += 0x14)
{
NvGpuASRemap Args = MemoryHelper.Read<NvGpuASRemap>(Context.Memory, InputPosition);
NvGpuASRemap args = MemoryHelper.Read<NvGpuASRemap>(context.Memory, inputPosition);
NvGpuVmm Vmm = GetASCtx(Context).Vmm;
NvGpuVmm vmm = GetASCtx(context).Vmm;
NvMapHandle Map = NvMapIoctl.GetNvMapWithFb(Context, Args.NvMapHandle);
NvMapHandle map = NvMapIoctl.GetNvMapWithFb(context, args.NvMapHandle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid NvMap handle 0x{Args.NvMapHandle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid NvMap handle 0x{args.NvMapHandle:x8}!");
return NvResult.InvalidInput;
}
long Result = Vmm.Map(Map.Address, (long)(uint)Args.Offset << 16,
(long)(uint)Args.Pages << 16);
long result = vmm.Map(map.Address, (long)(uint)args.Offset << 16,
(long)(uint)args.Pages << 16);
if (Result < 0)
if (result < 0)
{
Logger.PrintWarning(LogClass.ServiceNv,
$"Page 0x{Args.Offset:x16} size 0x{Args.Pages:x16} not allocated!");
$"Page 0x{args.Offset:x16} size 0x{args.Pages:x16} not allocated!");
return NvResult.InvalidInput;
}
@ -317,14 +317,14 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuAS
return NvResult.Success;
}
public static NvGpuASCtx GetASCtx(ServiceCtx Context)
public static NvGpuASCtx GetASCtx(ServiceCtx context)
{
return ASCtxs.GetOrAdd(Context.Process, (Key) => new NvGpuASCtx(Context));
return _asCtxs.GetOrAdd(context.Process, (key) => new NvGpuASCtx(context));
}
public static void UnloadProcess(KProcess Process)
public static void UnloadProcess(KProcess process)
{
ASCtxs.TryRemove(Process, out _);
_asCtxs.TryRemove(process, out _);
}
}
}

192
Ryujinx.HLE/HOS/Services/Nv/NvGpuGpu/NvGpuGpuIoctl.cs
View file

@ -7,181 +7,181 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvGpuGpu
{
class NvGpuGpuIoctl
{
private static Stopwatch PTimer;
private static Stopwatch _pTimer;
private static double TicksToNs;
private static double _ticksToNs;
static NvGpuGpuIoctl()
{
PTimer = new Stopwatch();
_pTimer = new Stopwatch();
PTimer.Start();
_pTimer.Start();
TicksToNs = (1.0 / Stopwatch.Frequency) * 1_000_000_000;
_ticksToNs = (1.0 / Stopwatch.Frequency) * 1_000_000_000;
}
public static int ProcessIoctl(ServiceCtx Context, int Cmd)
public static int ProcessIoctl(ServiceCtx context, int cmd)
{
switch (Cmd & 0xffff)
switch (cmd & 0xffff)
{
case 0x4701: return ZcullGetCtxSize (Context);
case 0x4702: return ZcullGetInfo (Context);
case 0x4703: return ZbcSetTable (Context);
case 0x4705: return GetCharacteristics(Context);
case 0x4706: return GetTpcMasks (Context);
case 0x4714: return GetActiveSlotMask (Context);
case 0x471c: return GetGpuTime (Context);
case 0x4701: return ZcullGetCtxSize (context);
case 0x4702: return ZcullGetInfo (context);
case 0x4703: return ZbcSetTable (context);
case 0x4705: return GetCharacteristics(context);
case 0x4706: return GetTpcMasks (context);
case 0x4714: return GetActiveSlotMask (context);
case 0x471c: return GetGpuTime (context);
}
throw new NotImplementedException(Cmd.ToString("x8"));
throw new NotImplementedException(cmd.ToString("x8"));
}
private static int ZcullGetCtxSize(ServiceCtx Context)
private static int ZcullGetCtxSize(ServiceCtx context)
{
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuGpuZcullGetCtxSize Args = new NvGpuGpuZcullGetCtxSize();
NvGpuGpuZcullGetCtxSize args = new NvGpuGpuZcullGetCtxSize();
Args.Size = 1;
args.Size = 1;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int ZcullGetInfo(ServiceCtx Context)
private static int ZcullGetInfo(ServiceCtx context)
{
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuGpuZcullGetInfo Args = new NvGpuGpuZcullGetInfo();
NvGpuGpuZcullGetInfo args = new NvGpuGpuZcullGetInfo();
Args.WidthAlignPixels = 0x20;
Args.HeightAlignPixels = 0x20;
Args.PixelSquaresByAliquots = 0x400;
Args.AliquotTotal = 0x800;
Args.RegionByteMultiplier = 0x20;
Args.RegionHeaderSize = 0x20;
Args.SubregionHeaderSize = 0xc0;
Args.SubregionWidthAlignPixels = 0x20;
Args.SubregionHeightAlignPixels = 0x40;
Args.SubregionCount = 0x10;
args.WidthAlignPixels = 0x20;
args.HeightAlignPixels = 0x20;
args.PixelSquaresByAliquots = 0x400;
args.AliquotTotal = 0x800;
args.RegionByteMultiplier = 0x20;
args.RegionHeaderSize = 0x20;
args.SubregionHeaderSize = 0xc0;
args.SubregionWidthAlignPixels = 0x20;
args.SubregionHeightAlignPixels = 0x40;
args.SubregionCount = 0x10;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int ZbcSetTable(ServiceCtx Context)
private static int ZbcSetTable(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int GetCharacteristics(ServiceCtx Context)
private static int GetCharacteristics(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuGpuGetCharacteristics Args = MemoryHelper.Read<NvGpuGpuGetCharacteristics>(Context.Memory, InputPosition);
NvGpuGpuGetCharacteristics args = MemoryHelper.Read<NvGpuGpuGetCharacteristics>(context.Memory, inputPosition);
Args.BufferSize = 0xa0;
args.BufferSize = 0xa0;
Args.Arch = 0x120;
Args.Impl = 0xb;
Args.Rev = 0xa1;
Args.NumGpc = 0x1;
Args.L2CacheSize = 0x40000;
Args.OnBoardVideoMemorySize = 0x0;
Args.NumTpcPerGpc = 0x2;
Args.BusType = 0x20;
Args.BigPageSize = 0x20000;
Args.CompressionPageSize = 0x20000;
Args.PdeCoverageBitCount = 0x1b;
Args.AvailableBigPageSizes = 0x30000;
Args.GpcMask = 0x1;
Args.SmArchSmVersion = 0x503;
Args.SmArchSpaVersion = 0x503;
Args.SmArchWarpCount = 0x80;
Args.GpuVaBitCount = 0x28;
Args.Reserved = 0x0;
Args.Flags = 0x55;
Args.TwodClass = 0x902d;
Args.ThreedClass = 0xb197;
Args.ComputeClass = 0xb1c0;
Args.GpfifoClass = 0xb06f;
Args.InlineToMemoryClass = 0xa140;
Args.DmaCopyClass = 0xb0b5;
Args.MaxFbpsCount = 0x1;
Args.FbpEnMask = 0x0;
Args.MaxLtcPerFbp = 0x2;
Args.MaxLtsPerLtc = 0x1;
Args.MaxTexPerTpc = 0x0;
Args.MaxGpcCount = 0x1;
Args.RopL2EnMask0 = 0x21d70;
Args.RopL2EnMask1 = 0x0;
Args.ChipName = 0x6230326d67;
Args.GrCompbitStoreBaseHw = 0x0;
args.Arch = 0x120;
args.Impl = 0xb;
args.Rev = 0xa1;
args.NumGpc = 0x1;
args.L2CacheSize = 0x40000;
args.OnBoardVideoMemorySize = 0x0;
args.NumTpcPerGpc = 0x2;
args.BusType = 0x20;
args.BigPageSize = 0x20000;
args.CompressionPageSize = 0x20000;
args.PdeCoverageBitCount = 0x1b;
args.AvailableBigPageSizes = 0x30000;
args.GpcMask = 0x1;
args.SmArchSmVersion = 0x503;
args.SmArchSpaVersion = 0x503;
args.SmArchWarpCount = 0x80;
args.GpuVaBitCount = 0x28;
args.Reserved = 0x0;
args.Flags = 0x55;
args.TwodClass = 0x902d;
args.ThreedClass = 0xb197;
args.ComputeClass = 0xb1c0;
args.GpfifoClass = 0xb06f;
args.InlineToMemoryClass = 0xa140;
args.DmaCopyClass = 0xb0b5;
args.MaxFbpsCount = 0x1;
args.FbpEnMask = 0x0;
args.MaxLtcPerFbp = 0x2;
args.MaxLtsPerLtc = 0x1;
args.MaxTexPerTpc = 0x0;
args.MaxGpcCount = 0x1;
args.RopL2EnMask0 = 0x21d70;
args.RopL2EnMask1 = 0x0;
args.ChipName = 0x6230326d67;
args.GrCompbitStoreBaseHw = 0x0;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int GetTpcMasks(ServiceCtx Context)
private static int GetTpcMasks(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuGpuGetTpcMasks Args = MemoryHelper.Read<NvGpuGpuGetTpcMasks>(Context.Memory, InputPosition);
NvGpuGpuGetTpcMasks args = MemoryHelper.Read<NvGpuGpuGetTpcMasks>(context.Memory, inputPosition);
if (Args.MaskBufferSize != 0)
if (args.MaskBufferSize != 0)
{
Args.TpcMask = 3;
args.TpcMask = 3;
}
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int GetActiveSlotMask(ServiceCtx Context)
private static int GetActiveSlotMask(ServiceCtx context)
{
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvGpuGpuGetActiveSlotMask Args = new NvGpuGpuGetActiveSlotMask();
NvGpuGpuGetActiveSlotMask args = new NvGpuGpuGetActiveSlotMask();
Args.Slot = 0x07;
Args.Mask = 0x01;
args.Slot = 0x07;
args.Mask = 0x01;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int GetGpuTime(ServiceCtx Context)
private static int GetGpuTime(ServiceCtx context)
{
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Context.Memory.WriteInt64(OutputPosition, GetPTimerNanoSeconds());
context.Memory.WriteInt64(outputPosition, GetPTimerNanoSeconds());
return NvResult.Success;
}
private static long GetPTimerNanoSeconds()
{
double Ticks = PTimer.ElapsedTicks;
double ticks = _pTimer.ElapsedTicks;
return (long)(Ticks * TicksToNs) & 0xff_ffff_ffff_ffff;
return (long)(ticks * _ticksToNs) & 0xff_ffff_ffff_ffff;
}
}
}

243
Ryujinx.HLE/HOS/Services/Nv/NvHostChannel/NvHostChannelIoctl.cs
View file

@ -11,62 +11,57 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostChannel
{
class NvHostChannelIoctl
{
private static ConcurrentDictionary<KProcess, NvChannel> Channels;
private static ConcurrentDictionary<KProcess, NvChannel> _channels;
static NvHostChannelIoctl()
{
Channels = new ConcurrentDictionary<KProcess, NvChannel>();
_channels = new ConcurrentDictionary<KProcess, NvChannel>();
}
public static int ProcessIoctl(ServiceCtx Context, int Cmd)
public static int ProcessIoctl(ServiceCtx context, int cmd)
{
switch (Cmd & 0xffff)
switch (cmd & 0xffff)
{
case 0x0001: return Submit (Context);
case 0x0002: return GetSyncpoint (Context);
case 0x0003: return GetWaitBase (Context);
case 0x0009: return MapBuffer (Context);
case 0x000a: return UnmapBuffer (Context);
case 0x4714: return SetUserData (Context);
case 0x4801: return SetNvMap (Context);
case 0x4803: return SetTimeout (Context);
case 0x4808: return SubmitGpfifo (Context);
case 0x4809: return AllocObjCtx (Context);
case 0x480b: return ZcullBind (Context);
case 0x480c: return SetErrorNotifier (Context);
case 0x480d: return SetPriority (Context);
case 0x481a: return AllocGpfifoEx2 (Context);
case 0x481b: return KickoffPbWithAttr(Context);
case 0x0001: return Submit (context);
case 0x0002: return GetSyncpoint (context);
case 0x0003: return GetWaitBase (context);
case 0x0009: return MapBuffer (context);
case 0x000a: return UnmapBuffer (context);
case 0x480b: return ZcullBind (context);
case 0x480c: return SetErrorNotifier (context);
case 0x4803: return SetTimeout (context);
case 0x481a: return AllocGpfifoEx2 (context);
case 0x481b: return KickoffPbWithAttr(context);
}
throw new NotImplementedException(Cmd.ToString("x8"));
throw new NotImplementedException(cmd.ToString("x8"));
}
private static int Submit(ServiceCtx Context)
private static int Submit(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostChannelSubmit Args = MemoryHelper.Read<NvHostChannelSubmit>(Context.Memory, InputPosition);
NvHostChannelSubmit args = MemoryHelper.Read<NvHostChannelSubmit>(context.Memory, inputPosition);
NvGpuVmm Vmm = NvGpuASIoctl.GetASCtx(Context).Vmm;
NvGpuVmm vmm = NvGpuASIoctl.GetASCtx(context).Vmm;
for (int Index = 0; Index < Args.CmdBufsCount; Index++)
for (int index = 0; index < args.CmdBufsCount; index++)
{
long CmdBufOffset = InputPosition + 0x10 + Index * 0xc;
long cmdBufOffset = inputPosition + 0x10 + index * 0xc;
NvHostChannelCmdBuf CmdBuf = MemoryHelper.Read<NvHostChannelCmdBuf>(Context.Memory, CmdBufOffset);
NvHostChannelCmdBuf cmdBuf = MemoryHelper.Read<NvHostChannelCmdBuf>(context.Memory, cmdBufOffset);
NvMapHandle Map = NvMapIoctl.GetNvMap(Context, CmdBuf.MemoryId);
NvMapHandle map = NvMapIoctl.GetNvMap(context, cmdBuf.MemoryId);
int[] CmdBufData = new int[CmdBuf.WordsCount];
int[] cmdBufData = new int[cmdBuf.WordsCount];
for (int Offset = 0; Offset < CmdBufData.Length; Offset++)
for (int offset = 0; offset < cmdBufData.Length; offset++)
{
CmdBufData[Offset] = Context.Memory.ReadInt32(Map.Address + CmdBuf.Offset + Offset * 4);
cmdBufData[offset] = context.Memory.ReadInt32(map.Address + cmdBuf.Offset + offset * 4);
}
Context.Device.Gpu.PushCommandBuffer(Vmm, CmdBufData);
context.Device.Gpu.PushCommandBuffer(vmm, cmdBufData);
}
//TODO: Relocation, waitchecks, etc.
@ -74,99 +69,99 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostChannel
return NvResult.Success;
}
private static int GetSyncpoint(ServiceCtx Context)
private static int GetSyncpoint(ServiceCtx context)
{
//TODO
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostChannelGetParamArg Args = MemoryHelper.Read<NvHostChannelGetParamArg>(Context.Memory, InputPosition);
NvHostChannelGetParamArg args = MemoryHelper.Read<NvHostChannelGetParamArg>(context.Memory, inputPosition);
Args.Value = 0;
args.Value = 0;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int GetWaitBase(ServiceCtx Context)
private static int GetWaitBase(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostChannelGetParamArg Args = MemoryHelper.Read<NvHostChannelGetParamArg>(Context.Memory, InputPosition);
NvHostChannelGetParamArg args = MemoryHelper.Read<NvHostChannelGetParamArg>(context.Memory, inputPosition);
Args.Value = 0;
args.Value = 0;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int MapBuffer(ServiceCtx Context)
private static int MapBuffer(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostChannelMapBuffer Args = MemoryHelper.Read<NvHostChannelMapBuffer>(Context.Memory, InputPosition);
NvHostChannelMapBuffer args = MemoryHelper.Read<NvHostChannelMapBuffer>(context.Memory, inputPosition);
NvGpuVmm Vmm = NvGpuASIoctl.GetASCtx(Context).Vmm;
NvGpuVmm vmm = NvGpuASIoctl.GetASCtx(context).Vmm;
for (int Index = 0; Index < Args.NumEntries; Index++)
for (int index = 0; index < args.NumEntries; index++)
{
int Handle = Context.Memory.ReadInt32(InputPosition + 0xc + Index * 8);
int handle = context.Memory.ReadInt32(inputPosition + 0xc + index * 8);
NvMapHandle Map = NvMapIoctl.GetNvMap(Context, Handle);
NvMapHandle map = NvMapIoctl.GetNvMap(context, handle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{handle:x8}!");
return NvResult.InvalidInput;
}
lock (Map)
lock (map)
{
if (Map.DmaMapAddress == 0)
if (map.DmaMapAddress == 0)
{
Map.DmaMapAddress = Vmm.MapLow(Map.Address, Map.Size);
map.DmaMapAddress = vmm.MapLow(map.Address, map.Size);
}
Context.Memory.WriteInt32(OutputPosition + 0xc + 4 + Index * 8, (int)Map.DmaMapAddress);
context.Memory.WriteInt32(outputPosition + 0xc + 4 + index * 8, (int)map.DmaMapAddress);
}
}
return NvResult.Success;
}
private static int UnmapBuffer(ServiceCtx Context)
private static int UnmapBuffer(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
NvHostChannelMapBuffer Args = MemoryHelper.Read<NvHostChannelMapBuffer>(Context.Memory, InputPosition);
NvHostChannelMapBuffer args = MemoryHelper.Read<NvHostChannelMapBuffer>(context.Memory, inputPosition);
NvGpuVmm Vmm = NvGpuASIoctl.GetASCtx(Context).Vmm;
NvGpuVmm vmm = NvGpuASIoctl.GetASCtx(context).Vmm;
for (int Index = 0; Index < Args.NumEntries; Index++)
for (int index = 0; index < args.NumEntries; index++)
{
int Handle = Context.Memory.ReadInt32(InputPosition + 0xc + Index * 8);
int handle = context.Memory.ReadInt32(inputPosition + 0xc + index * 8);
NvMapHandle Map = NvMapIoctl.GetNvMap(Context, Handle);
NvMapHandle map = NvMapIoctl.GetNvMap(context, handle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{handle:x8}!");
return NvResult.InvalidInput;
}
lock (Map)
lock (map)
{
if (Map.DmaMapAddress != 0)
if (map.DmaMapAddress != 0)
{
Vmm.Free(Map.DmaMapAddress, Map.Size);
vmm.Free(map.DmaMapAddress, map.Size);
Map.DmaMapAddress = 0;
map.DmaMapAddress = 0;
}
}
}
@ -174,146 +169,146 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostChannel
return NvResult.Success;
}
private static int SetUserData(ServiceCtx Context)
private static int SetUserData(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int SetNvMap(ServiceCtx Context)
private static int SetNvMap(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int SetTimeout(ServiceCtx Context)
private static int SetTimeout(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
GetChannel(Context).Timeout = Context.Memory.ReadInt32(InputPosition);
GetChannel(context).Timeout = context.Memory.ReadInt32(inputPosition);
return NvResult.Success;
}
private static int SubmitGpfifo(ServiceCtx Context)
private static int SubmitGpfifo(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostChannelSubmitGpfifo Args = MemoryHelper.Read<NvHostChannelSubmitGpfifo>(Context.Memory, InputPosition);
NvHostChannelSubmitGpfifo args = MemoryHelper.Read<NvHostChannelSubmitGpfifo>(context.Memory, inputPosition);
NvGpuVmm Vmm = NvGpuASIoctl.GetASCtx(Context).Vmm;;
NvGpuVmm vmm = NvGpuASIoctl.GetASCtx(context).Vmm;
for (int Index = 0; Index < Args.NumEntries; Index++)
for (int index = 0; index < args.NumEntries; index++)
{
long Gpfifo = Context.Memory.ReadInt64(InputPosition + 0x18 + Index * 8);
long gpfifo = context.Memory.ReadInt64(inputPosition + 0x18 + index * 8);
PushGpfifo(Context, Vmm, Gpfifo);
PushGpfifo(context, vmm, gpfifo);
}
Args.SyncptId = 0;
Args.SyncptValue = 0;
args.SyncptId = 0;
args.SyncptValue = 0;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int AllocObjCtx(ServiceCtx Context)
private static int AllocObjCtx(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int ZcullBind(ServiceCtx Context)
private static int ZcullBind(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int SetErrorNotifier(ServiceCtx Context)
private static int SetErrorNotifier(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int SetPriority(ServiceCtx Context)
private static int SetPriority(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int AllocGpfifoEx2(ServiceCtx Context)
private static int AllocGpfifoEx2(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int KickoffPbWithAttr(ServiceCtx Context)
private static int KickoffPbWithAttr(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostChannelSubmitGpfifo Args = MemoryHelper.Read<NvHostChannelSubmitGpfifo>(Context.Memory, InputPosition);
NvHostChannelSubmitGpfifo args = MemoryHelper.Read<NvHostChannelSubmitGpfifo>(context.Memory, inputPosition);
NvGpuVmm Vmm = NvGpuASIoctl.GetASCtx(Context).Vmm;;
NvGpuVmm vmm = NvGpuASIoctl.GetASCtx(context).Vmm;
for (int Index = 0; Index < Args.NumEntries; Index++)
for (int index = 0; index < args.NumEntries; index++)
{
long Gpfifo = Context.Memory.ReadInt64(Args.Address + Index * 8);
long gpfifo = context.Memory.ReadInt64(args.Address + index * 8);
PushGpfifo(Context, Vmm, Gpfifo);
PushGpfifo(context, vmm, gpfifo);
}
Args.SyncptId = 0;
Args.SyncptValue = 0;
args.SyncptId = 0;
args.SyncptValue = 0;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static void PushGpfifo(ServiceCtx Context, NvGpuVmm Vmm, long Gpfifo)
private static void PushGpfifo(ServiceCtx context, NvGpuVmm vmm, long gpfifo)
{
Context.Device.Gpu.Pusher.Push(Vmm, Gpfifo);
context.Device.Gpu.Pusher.Push(vmm, gpfifo);
}
public static NvChannel GetChannel(ServiceCtx Context)
public static NvChannel GetChannel(ServiceCtx context)
{
return Channels.GetOrAdd(Context.Process, (Key) => new NvChannel());
return _channels.GetOrAdd(context.Process, (key) => new NvChannel());
}
public static void UnloadProcess(KProcess Process)
public static void UnloadProcess(KProcess process)
{
Channels.TryRemove(Process, out _);
_channels.TryRemove(process, out _);
}
}
}

282
Ryujinx.HLE/HOS/Services/Nv/NvHostCtrl/NvHostCtrlIoctl.cs
View file

@ -10,116 +10,116 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
{
class NvHostCtrlIoctl
{
private static ConcurrentDictionary<KProcess, NvHostCtrlUserCtx> UserCtxs;
private static ConcurrentDictionary<KProcess, NvHostCtrlUserCtx> _userCtxs;
private static bool IsProductionMode = true;
private static bool _isProductionMode = true;
static NvHostCtrlIoctl()
{
UserCtxs = new ConcurrentDictionary<KProcess, NvHostCtrlUserCtx>();
_userCtxs = new ConcurrentDictionary<KProcess, NvHostCtrlUserCtx>();
if (Set.NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object ProductionModeSetting))
if (Set.NxSettings.Settings.TryGetValue("nv!rmos_set_production_mode", out object productionModeSetting))
{
IsProductionMode = ((string)ProductionModeSetting) != "0"; // Default value is ""
_isProductionMode = ((string)productionModeSetting) != "0"; // Default value is ""
}
}
public static int ProcessIoctl(ServiceCtx Context, int Cmd)
public static int ProcessIoctl(ServiceCtx context, int cmd)
{
switch (Cmd & 0xffff)
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);
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"));
throw new NotImplementedException(cmd.ToString("x8"));
}
private static int SyncptRead(ServiceCtx Context)
private static int SyncptRead(ServiceCtx context)
{
return SyncptReadMinOrMax(Context, Max: false);
return SyncptReadMinOrMax(context, max: false);
}
private static int SyncptIncr(ServiceCtx Context)
private static int SyncptIncr(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
int Id = Context.Memory.ReadInt32(InputPosition);
int id = context.Memory.ReadInt32(inputPosition);
if ((uint)Id >= NvHostSyncpt.SyncptsCount)
if ((uint)id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
GetUserCtx(Context).Syncpt.Increment(Id);
GetUserCtx(context).Syncpt.Increment(id);
return NvResult.Success;
}
private static int SyncptWait(ServiceCtx Context)
private static int SyncptWait(ServiceCtx context)
{
return SyncptWait(Context, Extended: false);
return SyncptWait(context, extended: false);
}
private static int SyncptWaitEx(ServiceCtx Context)
private static int SyncptWaitEx(ServiceCtx context)
{
return SyncptWait(Context, Extended: true);
return SyncptWait(context, extended: true);
}
private static int SyncptReadMax(ServiceCtx Context)
private static int SyncptReadMax(ServiceCtx context)
{
return SyncptReadMinOrMax(Context, Max: true);
return SyncptReadMinOrMax(context, max: true);
}
private static int GetConfig(ServiceCtx Context)
private static int GetConfig(ServiceCtx context)
{
if (!IsProductionMode)
if (!_isProductionMode)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
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);
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))
if (Set.NxSettings.Settings.TryGetValue($"{domain}!{name}", out object nvSetting))
{
byte[] SettingBuffer = new byte[0x101];
byte[] settingBuffer = new byte[0x101];
if (NvSetting is string StringValue)
if (nvSetting is string stringValue)
{
if (StringValue.Length > 0x100)
if (stringValue.Length > 0x100)
{
Logger.PrintError(LogClass.ServiceNv, $"{Domain}!{Name} String value size is too big!");
Logger.PrintError(LogClass.ServiceNv, $"{domain}!{name} String value size is too big!");
}
else
{
SettingBuffer = Encoding.ASCII.GetBytes(StringValue + "\0");
settingBuffer = Encoding.ASCII.GetBytes(stringValue + "\0");
}
}
if (NvSetting is int IntValue)
if (nvSetting is int intValue)
{
SettingBuffer = BitConverter.GetBytes(IntValue);
settingBuffer = BitConverter.GetBytes(intValue);
}
else if (NvSetting is bool BoolValue)
else if (nvSetting is bool boolValue)
{
SettingBuffer[0] = BoolValue ? (byte)1 : (byte)0;
settingBuffer[0] = boolValue ? (byte)1 : (byte)0;
}
else
{
throw new NotImplementedException(NvSetting.GetType().Name);
throw new NotImplementedException(nvSetting.GetType().Name);
}
Context.Memory.WriteBytes(OutputPosition + 0x82, SettingBuffer);
context.Memory.WriteBytes(outputPosition + 0x82, settingBuffer);
Logger.PrintDebug(LogClass.ServiceNv, $"Got setting {Domain}!{Name}");
Logger.PrintDebug(LogClass.ServiceNv, $"Got setting {domain}!{name}");
}
return NvResult.Success;
@ -128,156 +128,156 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
return NvResult.NotAvailableInProduction;
}
private static int EventWait(ServiceCtx Context)
private static int EventWait(ServiceCtx context)
{
return EventWait(Context, Async: false);
return EventWait(context, async: false);
}
private static int EventWaitAsync(ServiceCtx Context)
private static int EventWaitAsync(ServiceCtx context)
{
return EventWait(Context, Async: true);
return EventWait(context, async: true);
}
private static int EventRegister(ServiceCtx Context)
private static int EventRegister(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
int EventId = Context.Memory.ReadInt32(InputPosition);
int eventId = context.Memory.ReadInt32(inputPosition);
Logger.PrintStub(LogClass.ServiceNv, "Stubbed.");
return NvResult.Success;
}
private static int SyncptReadMinOrMax(ServiceCtx Context, bool Max)
private static int SyncptReadMinOrMax(ServiceCtx context, bool max)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostCtrlSyncptRead Args = MemoryHelper.Read<NvHostCtrlSyncptRead>(Context.Memory, InputPosition);
NvHostCtrlSyncptRead args = MemoryHelper.Read<NvHostCtrlSyncptRead>(context.Memory, inputPosition);
if ((uint)Args.Id >= NvHostSyncpt.SyncptsCount)
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
if (Max)
if (max)
{
Args.Value = GetUserCtx(Context).Syncpt.GetMax(Args.Id);
args.Value = GetUserCtx(context).Syncpt.GetMax(args.Id);
}
else
{
Args.Value = GetUserCtx(Context).Syncpt.GetMin(Args.Id);
args.Value = GetUserCtx(context).Syncpt.GetMin(args.Id);
}
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int SyncptWait(ServiceCtx Context, bool Extended)
private static int SyncptWait(ServiceCtx context, bool extended)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostCtrlSyncptWait Args = MemoryHelper.Read<NvHostCtrlSyncptWait>(Context.Memory, InputPosition);
NvHostCtrlSyncptWait args = MemoryHelper.Read<NvHostCtrlSyncptWait>(context.Memory, inputPosition);
NvHostSyncpt Syncpt = GetUserCtx(Context).Syncpt;
NvHostSyncpt syncpt = GetUserCtx(context).Syncpt;
if ((uint)Args.Id >= NvHostSyncpt.SyncptsCount)
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
int Result;
int result;
if (Syncpt.MinCompare(Args.Id, Args.Thresh))
if (syncpt.MinCompare(args.Id, args.Thresh))
{
Result = NvResult.Success;
result = NvResult.Success;
}
else if (Args.Timeout == 0)
else if (args.Timeout == 0)
{
Result = NvResult.TryAgain;
result = NvResult.TryAgain;
}
else
{
Logger.PrintDebug(LogClass.ServiceNv, "Waiting syncpt with timeout of " + Args.Timeout + "ms...");
Logger.PrintDebug(LogClass.ServiceNv, "Waiting syncpt with timeout of " + args.Timeout + "ms...");
using (ManualResetEvent WaitEvent = new ManualResetEvent(false))
using (ManualResetEvent waitEvent = new ManualResetEvent(false))
{
Syncpt.AddWaiter(Args.Thresh, WaitEvent);
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;
int timeout = args.Timeout;
if (Timeout < -1)
if (timeout < -1)
{
Timeout = int.MaxValue;
timeout = int.MaxValue;
}
if (Timeout == -1)
if (timeout == -1)
{
WaitEvent.WaitOne();
waitEvent.WaitOne();
Result = NvResult.Success;
result = NvResult.Success;
}
else if (WaitEvent.WaitOne(Timeout))
else if (waitEvent.WaitOne(timeout))
{
Result = NvResult.Success;
result = NvResult.Success;
}
else
{
Result = NvResult.TimedOut;
result = NvResult.TimedOut;
}
}
Logger.PrintDebug(LogClass.ServiceNv, "Resuming...");
}
if (Extended)
if (extended)
{
Context.Memory.WriteInt32(OutputPosition + 0xc, Syncpt.GetMin(Args.Id));
context.Memory.WriteInt32(outputPosition + 0xc, syncpt.GetMin(args.Id));
}
return Result;
return result;
}
private static int EventWait(ServiceCtx Context, bool Async)
private static int EventWait(ServiceCtx context, bool async)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvHostCtrlSyncptWaitEx Args = MemoryHelper.Read<NvHostCtrlSyncptWaitEx>(Context.Memory, InputPosition);
NvHostCtrlSyncptWaitEx args = MemoryHelper.Read<NvHostCtrlSyncptWaitEx>(context.Memory, inputPosition);
if ((uint)Args.Id >= NvHostSyncpt.SyncptsCount)
if ((uint)args.Id >= NvHostSyncpt.SyncptsCount)
{
return NvResult.InvalidInput;
}
void WriteArgs()
{
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
}
NvHostSyncpt Syncpt = GetUserCtx(Context).Syncpt;
NvHostSyncpt syncpt = GetUserCtx(context).Syncpt;
if (Syncpt.MinCompare(Args.Id, Args.Thresh))
if (syncpt.MinCompare(args.Id, args.Thresh))
{
Args.Value = Syncpt.GetMin(Args.Id);
args.Value = syncpt.GetMin(args.Id);
WriteArgs();
return NvResult.Success;
}
if (!Async)
if (!async)
{
Args.Value = 0;
args.Value = 0;
}
if (Args.Timeout == 0)
if (args.Timeout == 0)
{
WriteArgs();
@ -286,114 +286,114 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
NvHostEvent Event;
int Result, EventIndex;
int result, eventIndex;
if (Async)
if (async)
{
EventIndex = Args.Value;
eventIndex = args.Value;
if ((uint)EventIndex >= NvHostCtrlUserCtx.EventsCount)
if ((uint)eventIndex >= NvHostCtrlUserCtx.EventsCount)
{
return NvResult.InvalidInput;
}
Event = GetUserCtx(Context).Events[EventIndex];
Event = GetUserCtx(context).Events[eventIndex];
}
else
{
Event = GetFreeEvent(Context, Syncpt, Args.Id, out EventIndex);
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.Id = args.Id;
Event.Thresh = args.Thresh;
Event.State = NvHostEventState.Waiting;
if (!Async)
if (!async)
{
Args.Value = ((Args.Id & 0xfff) << 16) | 0x10000000;
args.Value = ((args.Id & 0xfff) << 16) | 0x10000000;
}
else
{
Args.Value = Args.Id << 4;
args.Value = args.Id << 4;
}
Args.Value |= EventIndex;
args.Value |= eventIndex;
Result = NvResult.TryAgain;
result = NvResult.TryAgain;
}
else
{
Result = NvResult.InvalidInput;
result = NvResult.InvalidInput;
}
WriteArgs();
return Result;
return result;
}
private static NvHostEvent GetFreeEvent(
ServiceCtx Context,
NvHostSyncpt Syncpt,
int Id,
out int EventIndex)
ServiceCtx context,
NvHostSyncpt syncpt,
int id,
out int eventIndex)
{
NvHostEvent[] Events = GetUserCtx(Context).Events;
NvHostEvent[] events = GetUserCtx(context).Events;
EventIndex = NvHostCtrlUserCtx.EventsCount;
eventIndex = NvHostCtrlUserCtx.EventsCount;
int NullIndex = NvHostCtrlUserCtx.EventsCount;
int nullIndex = NvHostCtrlUserCtx.EventsCount;
for (int Index = 0; Index < NvHostCtrlUserCtx.EventsCount; Index++)
for (int index = 0; index < NvHostCtrlUserCtx.EventsCount; index++)
{
NvHostEvent Event = Events[Index];
NvHostEvent Event = events[index];
if (Event != null)
{
if (Event.State == NvHostEventState.Registered ||
Event.State == NvHostEventState.Free)
{
EventIndex = Index;
eventIndex = index;
if (Event.Id == Id)
if (Event.Id == id)
{
return Event;
}
}
}
else if (NullIndex == NvHostCtrlUserCtx.EventsCount)
else if (nullIndex == NvHostCtrlUserCtx.EventsCount)
{
NullIndex = Index;
nullIndex = index;
}
}
if (NullIndex < NvHostCtrlUserCtx.EventsCount)
if (nullIndex < NvHostCtrlUserCtx.EventsCount)
{
EventIndex = NullIndex;
eventIndex = nullIndex;
return Events[NullIndex] = new NvHostEvent();
return events[nullIndex] = new NvHostEvent();
}
if (EventIndex < NvHostCtrlUserCtx.EventsCount)
if (eventIndex < NvHostCtrlUserCtx.EventsCount)
{
return Events[EventIndex];
return events[eventIndex];
}
return null;
}
public static NvHostCtrlUserCtx GetUserCtx(ServiceCtx Context)
public static NvHostCtrlUserCtx GetUserCtx(ServiceCtx context)
{
return UserCtxs.GetOrAdd(Context.Process, (Key) => new NvHostCtrlUserCtx());
return _userCtxs.GetOrAdd(context.Process, (key) => new NvHostCtrlUserCtx());
}
public static void UnloadProcess(KProcess Process)
public static void UnloadProcess(KProcess process)
{
UserCtxs.TryRemove(Process, out _);
_userCtxs.TryRemove(process, out _);
}
}
}

4
Ryujinx.HLE/HOS/Services/Nv/NvHostCtrl/NvHostCtrlUserCtx.cs
View file

@ -5,9 +5,9 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
public const int LocksCount = 16;
public const int EventsCount = 64;
public NvHostSyncpt Syncpt { get; private set; }
public NvHostSyncpt Syncpt { get; }
public NvHostEvent[] Events { get; private set; }
public NvHostEvent[] Events { get; }
public NvHostCtrlUserCtx()
{

76
Ryujinx.HLE/HOS/Services/Nv/NvHostCtrl/NvHostSyncPt.cs
View file

@ -9,98 +9,98 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvHostCtrl
{
public const int SyncptsCount = 192;
private int[] CounterMin;
private int[] CounterMax;
private int[] _counterMin;
private int[] _counterMax;
private long EventMask;
private long _eventMask;
private ConcurrentDictionary<EventWaitHandle, int> Waiters;
private ConcurrentDictionary<EventWaitHandle, int> _waiters;
public NvHostSyncpt()
{
CounterMin = new int[SyncptsCount];
CounterMax = new int[SyncptsCount];
_counterMin = new int[SyncptsCount];
_counterMax = new int[SyncptsCount];
Waiters = new ConcurrentDictionary<EventWaitHandle, int>();
_waiters = new ConcurrentDictionary<EventWaitHandle, int>();
}
public int GetMin(int Id)
public int GetMin(int id)
{
return CounterMin[Id];
return _counterMin[id];
}
public int GetMax(int Id)
public int GetMax(int id)
{
return CounterMax[Id];
return _counterMax[id];
}
public int Increment(int Id)
public int Increment(int id)
{
if (((EventMask >> Id) & 1) != 0)
if (((_eventMask >> id) & 1) != 0)
{
Interlocked.Increment(ref CounterMax[Id]);
Interlocked.Increment(ref _counterMax[id]);
}
return IncrementMin(Id);
return IncrementMin(id);
}
public int IncrementMin(int Id)
public int IncrementMin(int id)
{
int Value = Interlocked.Increment(ref CounterMin[Id]);
int value = Interlocked.Increment(ref _counterMin[id]);
WakeUpWaiters(Id, Value);
WakeUpWaiters(id, value);
return Value;
return value;
}
public int IncrementMax(int Id)
public int IncrementMax(int id)
{
return Interlocked.Increment(ref CounterMax[Id]);
return Interlocked.Increment(ref _counterMax[id]);
}
public void AddWaiter(int Threshold, EventWaitHandle WaitEvent)
public void AddWaiter(int threshold, EventWaitHandle waitEvent)
{
if (!Waiters.TryAdd(WaitEvent, Threshold))
if (!_waiters.TryAdd(waitEvent, threshold))
{
throw new InvalidOperationException();
}
}
public bool RemoveWaiter(EventWaitHandle WaitEvent)
public bool RemoveWaiter(EventWaitHandle waitEvent)
{
return Waiters.TryRemove(WaitEvent, out _);
return _waiters.TryRemove(waitEvent, out _);
}
private void WakeUpWaiters(int Id, int NewValue)
private void WakeUpWaiters(int id, int newValue)
{
foreach (KeyValuePair<EventWaitHandle, int> KV in Waiters)
foreach (KeyValuePair<EventWaitHandle, int> kv in _waiters)
{
if (MinCompare(Id, NewValue, CounterMax[Id], KV.Value))
if (MinCompare(id, newValue, _counterMax[id], kv.Value))
{
KV.Key.Set();
kv.Key.Set();
Waiters.TryRemove(KV.Key, out _);
_waiters.TryRemove(kv.Key, out _);
}
}
}
public bool MinCompare(int Id, int Threshold)
public bool MinCompare(int id, int threshold)
{
return MinCompare(Id, CounterMin[Id], CounterMax[Id], Threshold);
return MinCompare(id, _counterMin[id], _counterMax[id], threshold);
}
private bool MinCompare(int Id, int Min, int Max, int Threshold)
private bool MinCompare(int id, int min, int max, int threshold)
{
int MinDiff = Min - Threshold;
int MaxDiff = Max - Threshold;
int minDiff = min - threshold;
int maxDiff = max - threshold;
if (((EventMask >> Id) & 1) != 0)
if (((_eventMask >> id) & 1) != 0)
{
return MinDiff >= 0;
return minDiff >= 0;
}
else
{
return (uint)MaxDiff >= (uint)MinDiff;
return (uint)maxDiff >= (uint)minDiff;
}
}
}

12
Ryujinx.HLE/HOS/Services/Nv/NvMap/NvMapHandle.cs
View file

@ -13,26 +13,26 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvMap
public bool Allocated;
public long DmaMapAddress;
private long Dupes;
private long _dupes;
public NvMapHandle()
{
Dupes = 1;
_dupes = 1;
}
public NvMapHandle(int Size) : this()
public NvMapHandle(int size) : this()
{
this.Size = Size;
Size = size;
}
public void IncrementRefCount()
{
Interlocked.Increment(ref Dupes);
Interlocked.Increment(ref _dupes);
}
public long DecrementRefCount()
{
return Interlocked.Decrement(ref Dupes);
return Interlocked.Decrement(ref _dupes);
}
}
}

230
Ryujinx.HLE/HOS/Services/Nv/NvMap/NvMapIoctl.cs
View file

@ -11,290 +11,290 @@ namespace Ryujinx.HLE.HOS.Services.Nv.NvMap
{
private const int FlagNotFreedYet = 1;
private static ConcurrentDictionary<KProcess, IdDictionary> Maps;
private static ConcurrentDictionary<KProcess, IdDictionary> _maps;
static NvMapIoctl()
{
Maps = new ConcurrentDictionary<KProcess, IdDictionary>();
_maps = new ConcurrentDictionary<KProcess, IdDictionary>();
}
public static int ProcessIoctl(ServiceCtx Context, int Cmd)
public static int ProcessIoctl(ServiceCtx context, int cmd)
{
switch (Cmd & 0xffff)
switch (cmd & 0xffff)
{
case 0x0101: return Create(Context);
case 0x0103: return FromId(Context);
case 0x0104: return Alloc (Context);
case 0x0105: return Free (Context);
case 0x0109: return Param (Context);
case 0x010e: return GetId (Context);
case 0x0101: return Create(context);
case 0x0103: return FromId(context);
case 0x0104: return Alloc (context);
case 0x0105: return Free (context);
case 0x0109: return Param (context);
case 0x010e: return GetId (context);
}
Logger.PrintWarning(LogClass.ServiceNv, $"Unsupported Ioctl command 0x{Cmd:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Unsupported Ioctl command 0x{cmd:x8}!");
return NvResult.NotSupported;
}
private static int Create(ServiceCtx Context)
private static int Create(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvMapCreate Args = MemoryHelper.Read<NvMapCreate>(Context.Memory, InputPosition);
NvMapCreate args = MemoryHelper.Read<NvMapCreate>(context.Memory, inputPosition);
if (Args.Size == 0)
if (args.Size == 0)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid size 0x{Args.Size:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid size 0x{args.Size:x8}!");
return NvResult.InvalidInput;
}
int Size = IntUtils.AlignUp(Args.Size, NvGpuVmm.PageSize);
int size = IntUtils.AlignUp(args.Size, NvGpuVmm.PageSize);
Args.Handle = AddNvMap(Context, new NvMapHandle(Size));
args.Handle = AddNvMap(context, new NvMapHandle(size));
Logger.PrintInfo(LogClass.ServiceNv, $"Created map {Args.Handle} with size 0x{Size:x8}!");
Logger.PrintInfo(LogClass.ServiceNv, $"Created map {args.Handle} with size 0x{size:x8}!");
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int FromId(ServiceCtx Context)
private static int FromId(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvMapFromId Args = MemoryHelper.Read<NvMapFromId>(Context.Memory, InputPosition);
NvMapFromId args = MemoryHelper.Read<NvMapFromId>(context.Memory, inputPosition);
NvMapHandle Map = GetNvMap(Context, Args.Id);
NvMapHandle map = GetNvMap(context, args.Id);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Args.Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{args.Handle:x8}!");
return NvResult.InvalidInput;
}
Map.IncrementRefCount();
map.IncrementRefCount();
Args.Handle = Args.Id;
args.Handle = args.Id;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int Alloc(ServiceCtx Context)
private static int Alloc(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvMapAlloc Args = MemoryHelper.Read<NvMapAlloc>(Context.Memory, InputPosition);
NvMapAlloc args = MemoryHelper.Read<NvMapAlloc>(context.Memory, inputPosition);
NvMapHandle Map = GetNvMap(Context, Args.Handle);
NvMapHandle map = GetNvMap(context, args.Handle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Args.Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{args.Handle:x8}!");
return NvResult.InvalidInput;
}
if ((Args.Align & (Args.Align - 1)) != 0)
if ((args.Align & (args.Align - 1)) != 0)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid alignment 0x{Args.Align:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid alignment 0x{args.Align:x8}!");
return NvResult.InvalidInput;
}
if ((uint)Args.Align < NvGpuVmm.PageSize)
if ((uint)args.Align < NvGpuVmm.PageSize)
{
Args.Align = NvGpuVmm.PageSize;
args.Align = NvGpuVmm.PageSize;
}
int Result = NvResult.Success;
int result = NvResult.Success;
if (!Map.Allocated)
if (!map.Allocated)
{
Map.Allocated = true;
map.Allocated = true;
Map.Align = Args.Align;
Map.Kind = (byte)Args.Kind;
map.Align = args.Align;
map.Kind = (byte)args.Kind;
int Size = IntUtils.AlignUp(Map.Size, NvGpuVmm.PageSize);
int size = IntUtils.AlignUp(map.Size, NvGpuVmm.PageSize);
long Address = Args.Address;
long address = args.Address;
if (Address == 0)
if (address == 0)
{
//When the address is zero, we need to allocate
//our own backing memory for the NvMap.
//TODO: Is this allocation inside the transfer memory?
Result = NvResult.OutOfMemory;
result = NvResult.OutOfMemory;
}
if (Result == NvResult.Success)
if (result == NvResult.Success)
{
Map.Size = Size;
Map.Address = Address;
map.Size = size;
map.Address = address;
}
}
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return Result;
return result;
}
private static int Free(ServiceCtx Context)
private static int Free(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvMapFree Args = MemoryHelper.Read<NvMapFree>(Context.Memory, InputPosition);
NvMapFree args = MemoryHelper.Read<NvMapFree>(context.Memory, inputPosition);
NvMapHandle Map = GetNvMap(Context, Args.Handle);
NvMapHandle map = GetNvMap(context, args.Handle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Args.Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{args.Handle:x8}!");
return NvResult.InvalidInput;
}
if (Map.DecrementRefCount() <= 0)
if (map.DecrementRefCount() <= 0)
{
DeleteNvMap(Context, Args.Handle);
DeleteNvMap(context, args.Handle);
Logger.PrintInfo(LogClass.ServiceNv, $"Deleted map {Args.Handle}!");
Logger.PrintInfo(LogClass.ServiceNv, $"Deleted map {args.Handle}!");
Args.Address = Map.Address;
Args.Flags = 0;
args.Address = map.Address;
args.Flags = 0;
}
else
{
Args.Address = 0;
Args.Flags = FlagNotFreedYet;
args.Address = 0;
args.Flags = FlagNotFreedYet;
}
Args.Size = Map.Size;
args.Size = map.Size;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int Param(ServiceCtx Context)
private static int Param(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvMapParam Args = MemoryHelper.Read<NvMapParam>(Context.Memory, InputPosition);
NvMapParam args = MemoryHelper.Read<NvMapParam>(context.Memory, inputPosition);
NvMapHandle Map = GetNvMap(Context, Args.Handle);
NvMapHandle map = GetNvMap(context, args.Handle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Args.Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{args.Handle:x8}!");
return NvResult.InvalidInput;
}
switch ((NvMapHandleParam)Args.Param)
switch ((NvMapHandleParam)args.Param)
{
case NvMapHandleParam.Size: Args.Result = Map.Size; break;
case NvMapHandleParam.Align: Args.Result = Map.Align; break;
case NvMapHandleParam.Heap: Args.Result = 0x40000000; break;
case NvMapHandleParam.Kind: Args.Result = Map.Kind; break;
case NvMapHandleParam.Compr: Args.Result = 0; break;
case NvMapHandleParam.Size: args.Result = map.Size; break;
case NvMapHandleParam.Align: args.Result = map.Align; break;
case NvMapHandleParam.Heap: args.Result = 0x40000000; break;
case NvMapHandleParam.Kind: args.Result = map.Kind; break;
case NvMapHandleParam.Compr: args.Result = 0; break;
//Note: Base is not supported and returns an error.
//Any other value also returns an error.
default: return NvResult.InvalidInput;
}
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int GetId(ServiceCtx Context)
private static int GetId(ServiceCtx context)
{
long InputPosition = Context.Request.GetBufferType0x21().Position;
long OutputPosition = Context.Request.GetBufferType0x22().Position;
long inputPosition = context.Request.GetBufferType0x21().Position;
long outputPosition = context.Request.GetBufferType0x22().Position;
NvMapGetId Args = MemoryHelper.Read<NvMapGetId>(Context.Memory, InputPosition);
NvMapGetId args = MemoryHelper.Read<NvMapGetId>(context.Memory, inputPosition);
NvMapHandle Map = GetNvMap(Context, Args.Handle);
NvMapHandle map = GetNvMap(context, args.Handle);
if (Map == null)
if (map == null)
{
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{Args.Handle:x8}!");
Logger.PrintWarning(LogClass.ServiceNv, $"Invalid handle 0x{args.Handle:x8}!");
return NvResult.InvalidInput;
}
Args.Id = Args.Handle;
args.Id = args.Handle;
MemoryHelper.Write(Context.Memory, OutputPosition, Args);
MemoryHelper.Write(context.Memory, outputPosition, args);
return NvResult.Success;
}
private static int AddNvMap(ServiceCtx Context, NvMapHandle Map)
private static int AddNvMap(ServiceCtx context, NvMapHandle map)
{
IdDictionary Dict = Maps.GetOrAdd(Context.Process, (Key) =>
IdDictionary dict = _maps.GetOrAdd(context.Process, (key) =>
{
IdDictionary NewDict = new IdDictionary();
IdDictionary newDict = new IdDictionary();
NewDict.Add(0, new NvMapHandle());
newDict.Add(0, new NvMapHandle());
return NewDict;
return newDict;
});
return Dict.Add(Map);
return dict.Add(map);
}
private static bool DeleteNvMap(ServiceCtx Context, int Handle)
private static bool DeleteNvMap(ServiceCtx context, int handle)
{
if (Maps.TryGetValue(Context.Process, out IdDictionary Dict))
if (_maps.TryGetValue(context.Process, out IdDictionary dict))
{
return Dict.Delete(Handle) != null;
return dict.Delete(handle) != null;
}
return false;
}
public static void InitializeNvMap(ServiceCtx Context)
public static void InitializeNvMap(ServiceCtx context)
{
IdDictionary Dict = Maps.GetOrAdd(Context.Process, (Key) =>new IdDictionary());
IdDictionary dict = _maps.GetOrAdd(context.Process, (key) =>new IdDictionary());
Dict.Add(0, new NvMapHandle());
dict.Add(0, new NvMapHandle());
}
public static NvMapHandle GetNvMapWithFb(ServiceCtx Context, int Handle)
public static NvMapHandle GetNvMapWithFb(ServiceCtx context, int handle)
{
if (Maps.TryGetValue(Context.Process, out IdDictionary Dict))
if (_maps.TryGetValue(context.Process, out IdDictionary dict))
{
return Dict.GetData<NvMapHandle>(Handle);
return dict.GetData<NvMapHandle>(handle);
}
return null;
}
public static NvMapHandle GetNvMap(ServiceCtx Context, int Handle)
public static NvMapHandle GetNvMap(ServiceCtx context, int handle)
{
if (Handle != 0 && Maps.TryGetValue(Context.Process, out IdDictionary Dict))
if (handle != 0 && _maps.TryGetValue(context.Process, out IdDictionary dict))
{
return Dict.GetData<NvMapHandle>(Handle);
return dict.GetData<NvMapHandle>(handle);
}
return null;
}
public static void UnloadProcess(KProcess Process)
public static void UnloadProcess(KProcess process)
{
Maps.TryRemove(Process, out _);
_maps.TryRemove(process, out _);
}
}
}