rjx-mirror/Ryujinx.HLE/HOS/Kernel/Process/KHandleTable.cs
gdkchan 22bacc6188
Improve kernel IPC implementation (#550)
* Implement some IPC related kernel SVCs properly

* Fix BLZ decompression when the segment also has a uncompressed chunck

* Set default cpu core on process start from ProgramLoader, remove debug message

* Load process capabilities properly on KIPs

* Fix a copy/paste error in UnmapPhysicalMemory64

* Implement smarter switching between old and new IPC system to support the old HLE services implementation without the manual switch

* Implement RegisterService on sm and AcceptSession (partial)

* Misc fixes and improvements on new IPC methods

* Move IPC related SVCs into a separate file, and logging on RegisterService (sm)

* Some small fixes related to receive list buffers and error cases

* Load NSOs using the correct pool partition

* Fix corner case on GetMaskFromMinMax where range is 64, doesn't happen in pratice however

* Fix send static buffer copy

* Session release, implement closing requests on client disconnect

* Implement ConnectToPort SVC

* KLightSession init
2019-01-18 20:26:39 -02:00

284 lines
No EOL
6.8 KiB
C#

using Ryujinx.HLE.HOS.Kernel.Common;
using Ryujinx.HLE.HOS.Kernel.Threading;
using System;
namespace Ryujinx.HLE.HOS.Kernel.Process
{
class KHandleTable
{
public const int SelfThreadHandle = (0x1ffff << 15) | 0;
public const int SelfProcessHandle = (0x1ffff << 15) | 1;
private Horizon _system;
private KHandleEntry[] _table;
private KHandleEntry _tableHead;
private KHandleEntry _nextFreeEntry;
private int _activeSlotsCount;
private int _size;
private ushort _idCounter;
public KHandleTable(Horizon system)
{
_system = system;
}
public KernelResult Initialize(int size)
{
if ((uint)size > 1024)
{
return KernelResult.OutOfMemory;
}
if (size < 1)
{
size = 1024;
}
_size = size;
_idCounter = 1;
_table = new KHandleEntry[size];
_tableHead = new KHandleEntry(0);
KHandleEntry entry = _tableHead;
for (int index = 0; index < size; index++)
{
_table[index] = entry;
entry.Next = new KHandleEntry(index + 1);
entry = entry.Next;
}
_table[size - 1].Next = null;
_nextFreeEntry = _tableHead;
return KernelResult.Success;
}
public KernelResult GenerateHandle(KAutoObject obj, out int handle)
{
handle = 0;
lock (_table)
{
if (_activeSlotsCount >= _size)
{
return KernelResult.HandleTableFull;
}
KHandleEntry entry = _nextFreeEntry;
_nextFreeEntry = entry.Next;
entry.Obj = obj;
entry.HandleId = _idCounter;
_activeSlotsCount++;
handle = (_idCounter << 15) | entry.Index;
obj.IncrementReferenceCount();
if ((short)(_idCounter + 1) >= 0)
{
_idCounter++;
}
else
{
_idCounter = 1;
}
}
return KernelResult.Success;
}
public KernelResult ReserveHandle(out int handle)
{
handle = 0;
lock (_table)
{
if (_activeSlotsCount >= _size)
{
return KernelResult.HandleTableFull;
}
KHandleEntry entry = _nextFreeEntry;
_nextFreeEntry = entry.Next;
_activeSlotsCount++;
handle = (_idCounter << 15) | entry.Index;
if ((short)(_idCounter + 1) >= 0)
{
_idCounter++;
}
else
{
_idCounter = 1;
}
}
return KernelResult.Success;
}
public void CancelHandleReservation(int handle)
{
int index = (handle >> 0) & 0x7fff;
int handleId = (handle >> 15);
lock (_table)
{
KHandleEntry entry = _table[index];
entry.Obj = null;
entry.Next = _nextFreeEntry;
_nextFreeEntry = entry;
_activeSlotsCount--;
}
}
public void SetReservedHandleObj(int handle, KAutoObject obj)
{
int index = (handle >> 0) & 0x7fff;
int handleId = (handle >> 15);
lock (_table)
{
KHandleEntry entry = _table[index];
entry.Obj = obj;
entry.HandleId = (ushort)(handle >> 15);
obj.IncrementReferenceCount();
}
}
public bool CloseHandle(int handle)
{
if ((handle >> 30) != 0 ||
handle == SelfThreadHandle ||
handle == SelfProcessHandle)
{
return false;
}
int index = (handle >> 0) & 0x7fff;
int handleId = (handle >> 15);
KAutoObject obj = null;
bool result = false;
lock (_table)
{
if (handleId != 0 && index < _size)
{
KHandleEntry entry = _table[index];
if ((obj = entry.Obj) != null && entry.HandleId == handleId)
{
entry.Obj = null;
entry.Next = _nextFreeEntry;
_nextFreeEntry = entry;
_activeSlotsCount--;
result = true;
}
}
}
if (result)
{
obj.DecrementReferenceCount();
}
return result;
}
public T GetObject<T>(int handle) where T : KAutoObject
{
int index = (handle >> 0) & 0x7fff;
int handleId = (handle >> 15);
lock (_table)
{
if ((handle >> 30) == 0 && handleId != 0 && index < _size)
{
KHandleEntry entry = _table[index];
if (entry.HandleId == handleId && entry.Obj is T obj)
{
return obj;
}
}
}
return default(T);
}
public KThread GetKThread(int handle)
{
if (handle == SelfThreadHandle)
{
return _system.Scheduler.GetCurrentThread();
}
else
{
return GetObject<KThread>(handle);
}
}
public KProcess GetKProcess(int handle)
{
if (handle == SelfProcessHandle)
{
return _system.Scheduler.GetCurrentProcess();
}
else
{
return GetObject<KProcess>(handle);
}
}
public void Destroy()
{
lock (_table)
{
for (int index = 0; index < _size; index++)
{
KHandleEntry entry = _table[index];
if (entry.Obj != null)
{
if (entry.Obj is IDisposable disposableObj)
{
disposableObj.Dispose();
}
entry.Obj = null;
entry.Next = _nextFreeEntry;
_nextFreeEntry = entry;
}
}
}
}
}
}