JinxRyu/Ryujinx.HLE/HOS/Services/ServerBase.cs

177 lines
6 KiB
C#
Raw Normal View History

using Ryujinx.Common;
using Ryujinx.HLE.HOS.Ipc;
using Ryujinx.HLE.HOS.Kernel.Common;
using Ryujinx.HLE.HOS.Kernel.Ipc;
using Ryujinx.HLE.HOS.Kernel.Process;
using Ryujinx.HLE.HOS.Kernel.Threading;
2018-02-04 23:08:20 +00:00
using System;
using System.IO;
namespace Ryujinx.HLE.HOS.Services
2018-02-04 23:08:20 +00:00
{
class ServerBase
2018-02-04 23:08:20 +00:00
{
private struct IpcRequest
2018-02-04 23:08:20 +00:00
{
public Switch Device { get; }
public KProcess Process => Thread?.Owner;
public KThread Thread { get; }
public KClientSession Session { get; }
public ulong MessagePtr { get; }
public ulong MessageSize { get; }
public IpcRequest(Switch device, KThread thread, KClientSession session, ulong messagePtr, ulong messageSize)
{
Device = device;
Thread = thread;
Session = session;
MessagePtr = messagePtr;
MessageSize = messageSize;
}
public void SignalDone(KernelResult result)
{
Thread.ObjSyncResult = result;
Thread.Reschedule(ThreadSchedState.Running);
}
}
private readonly AsyncWorkQueue<IpcRequest> _ipcProcessor;
public ServerBase(string name)
{
_ipcProcessor = new AsyncWorkQueue<IpcRequest>(Process, name);
}
public void PushMessage(Switch device, KThread thread, KClientSession session, ulong messagePtr, ulong messageSize)
{
_ipcProcessor.Add(new IpcRequest(device, thread, session, messagePtr, messageSize));
}
private void Process(IpcRequest message)
{
byte[] reqData = new byte[message.MessageSize];
message.Process.CpuMemory.Read(message.MessagePtr, reqData);
IpcMessage request = new IpcMessage(reqData, (long)message.MessagePtr);
IpcMessage response = new IpcMessage();
2018-02-04 23:08:20 +00:00
using (MemoryStream raw = new MemoryStream(request.RawData))
2018-02-04 23:08:20 +00:00
{
BinaryReader reqReader = new BinaryReader(raw);
2018-02-04 23:08:20 +00:00
if (request.Type == IpcMessageType.Request ||
request.Type == IpcMessageType.RequestWithContext)
2018-02-04 23:08:20 +00:00
{
response.Type = IpcMessageType.Response;
2018-02-04 23:08:20 +00:00
using (MemoryStream resMs = new MemoryStream())
2018-02-04 23:08:20 +00:00
{
BinaryWriter resWriter = new BinaryWriter(resMs);
2018-02-04 23:08:20 +00:00
ServiceCtx context = new ServiceCtx(
message.Device,
message.Process,
message.Process.CpuMemory,
message.Thread,
message.Session,
request,
response,
reqReader,
resWriter);
2018-02-04 23:08:20 +00:00
message.Session.Service.CallMethod(context);
2018-02-04 23:08:20 +00:00
response.RawData = resMs.ToArray();
2018-02-04 23:08:20 +00:00
}
}
else if (request.Type == IpcMessageType.Control ||
request.Type == IpcMessageType.ControlWithContext)
2018-02-04 23:08:20 +00:00
{
uint magic = (uint)reqReader.ReadUInt64();
uint cmdId = (uint)reqReader.ReadUInt64();
2018-02-04 23:08:20 +00:00
switch (cmdId)
2018-02-04 23:08:20 +00:00
{
case 0:
request = FillResponse(response, 0, message.Session.Service.ConvertToDomain());
break;
case 3:
request = FillResponse(response, 0, 0x1000);
break;
// TODO: Whats the difference between IpcDuplicateSession/Ex?
case 2:
case 4:
int unknown = reqReader.ReadInt32();
if (message.Process.HandleTable.GenerateHandle(message.Session, out int handle) != KernelResult.Success)
{
throw new InvalidOperationException("Out of handles!");
}
response.HandleDesc = IpcHandleDesc.MakeMove(handle);
request = FillResponse(response, 0);
break;
2018-02-04 23:08:20 +00:00
default: throw new NotImplementedException(cmdId.ToString());
2018-02-04 23:08:20 +00:00
}
}
else if (request.Type == IpcMessageType.CloseSession)
2018-02-04 23:08:20 +00:00
{
message.SignalDone(KernelResult.PortRemoteClosed);
return;
2018-02-04 23:08:20 +00:00
}
else
{
throw new NotImplementedException(request.Type.ToString());
2018-02-04 23:08:20 +00:00
}
message.Process.CpuMemory.Write(message.MessagePtr, response.GetBytes((long)message.MessagePtr));
2018-02-04 23:08:20 +00:00
}
message.SignalDone(KernelResult.Success);
2018-02-04 23:08:20 +00:00
}
private static IpcMessage FillResponse(IpcMessage response, long result, params int[] values)
2018-02-04 23:08:20 +00:00
{
using (MemoryStream ms = new MemoryStream())
2018-02-04 23:08:20 +00:00
{
BinaryWriter writer = new BinaryWriter(ms);
2018-02-04 23:08:20 +00:00
foreach (int value in values)
2018-02-04 23:08:20 +00:00
{
writer.Write(value);
2018-02-04 23:08:20 +00:00
}
return FillResponse(response, result, ms.ToArray());
2018-02-04 23:08:20 +00:00
}
}
private static IpcMessage FillResponse(IpcMessage response, long result, byte[] data = null)
2018-02-04 23:08:20 +00:00
{
response.Type = IpcMessageType.Response;
2018-02-04 23:08:20 +00:00
using (MemoryStream ms = new MemoryStream())
2018-02-04 23:08:20 +00:00
{
BinaryWriter writer = new BinaryWriter(ms);
2018-02-04 23:08:20 +00:00
writer.Write(IpcMagic.Sfco);
writer.Write(result);
2018-02-04 23:08:20 +00:00
if (data != null)
2018-02-04 23:08:20 +00:00
{
writer.Write(data);
2018-02-04 23:08:20 +00:00
}
response.RawData = ms.ToArray();
2018-02-04 23:08:20 +00:00
}
return response;
2018-02-04 23:08:20 +00:00
}
}
}