mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-10-01 12:30:00 +02:00
5d08e9b495
* hos: Cleanup the project Since a lot of changes has been done on the HOS project, there are some leftover here and there, or class just used in one service, things at wrong places, and more. This PR fixes that, additionnally to that, I've realigned some vars because I though it make the code more readable. * Address gdkchan feedback * addresses Thog feedback * Revert ElfSymbol
586 lines
No EOL
18 KiB
C#
586 lines
No EOL
18 KiB
C#
using LibHac.FsSystem;
|
|
using Ryujinx.Common;
|
|
using Ryujinx.Cpu;
|
|
using Ryujinx.HLE.HOS.Kernel.Common;
|
|
using Ryujinx.HLE.HOS.Kernel.Memory;
|
|
using Ryujinx.HLE.HOS.Kernel.Process;
|
|
using Ryujinx.HLE.Loaders.Executables;
|
|
using Ryujinx.HLE.Utilities;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Security.Cryptography;
|
|
|
|
namespace Ryujinx.HLE.HOS.Services.Ro
|
|
{
|
|
[Service("ldr:ro")]
|
|
[Service("ro:1")] // 7.0.0+
|
|
class IRoInterface : DisposableIpcService
|
|
{
|
|
private const int MaxNrr = 0x40;
|
|
private const int MaxNro = 0x40;
|
|
private const int MaxMapRetries = 0x200;
|
|
private const int GuardPagesSize = 0x4000;
|
|
|
|
private const uint NrrMagic = 0x3052524E;
|
|
private const uint NroMagic = 0x304F524E;
|
|
|
|
private List<NrrInfo> _nrrInfos;
|
|
private List<NroInfo> _nroInfos;
|
|
|
|
private KProcess _owner;
|
|
|
|
private static Random _random = new Random();
|
|
|
|
public IRoInterface(ServiceCtx context)
|
|
{
|
|
_nrrInfos = new List<NrrInfo>(MaxNrr);
|
|
_nroInfos = new List<NroInfo>(MaxNro);
|
|
_owner = null;
|
|
}
|
|
|
|
private ResultCode ParseNrr(out NrrInfo nrrInfo, ServiceCtx context, ulong nrrAddress, ulong nrrSize)
|
|
{
|
|
nrrInfo = null;
|
|
|
|
if (nrrSize == 0 || nrrAddress + nrrSize <= nrrAddress || (nrrSize & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidSize;
|
|
}
|
|
else if ((nrrAddress & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidAddress;
|
|
}
|
|
|
|
NrrHeader header = _owner.CpuMemory.Read<NrrHeader>(nrrAddress);
|
|
|
|
if (header.Magic != NrrMagic)
|
|
{
|
|
return ResultCode.InvalidNrr;
|
|
}
|
|
else if (header.NrrSize != nrrSize)
|
|
{
|
|
return ResultCode.InvalidSize;
|
|
}
|
|
|
|
List<byte[]> hashes = new List<byte[]>();
|
|
|
|
for (int i = 0; i < header.HashCount; i++)
|
|
{
|
|
byte[] temp = new byte[0x20];
|
|
|
|
_owner.CpuMemory.Read(nrrAddress + header.HashOffset + (uint)(i * 0x20), temp);
|
|
|
|
hashes.Add(temp);
|
|
}
|
|
|
|
nrrInfo = new NrrInfo((ulong)nrrAddress, header, hashes);
|
|
|
|
return ResultCode.Success;
|
|
}
|
|
|
|
public bool IsNroHashPresent(byte[] nroHash)
|
|
{
|
|
foreach (NrrInfo info in _nrrInfos)
|
|
{
|
|
foreach (byte[] hash in info.Hashes)
|
|
{
|
|
if (hash.SequenceEqual(nroHash))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool IsNroLoaded(byte[] nroHash)
|
|
{
|
|
foreach (NroInfo info in _nroInfos)
|
|
{
|
|
if (info.Hash.SequenceEqual(nroHash))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public ResultCode ParseNro(out NroInfo res, ServiceCtx context, ulong nroAddress, ulong nroSize, ulong bssAddress, ulong bssSize)
|
|
{
|
|
res = null;
|
|
|
|
if (_nroInfos.Count >= MaxNro)
|
|
{
|
|
return ResultCode.TooManyNro;
|
|
}
|
|
else if (nroSize == 0 || nroAddress + nroSize <= nroAddress || (nroSize & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidSize;
|
|
}
|
|
else if (bssSize != 0 && bssAddress + bssSize <= bssAddress)
|
|
{
|
|
return ResultCode.InvalidSize;
|
|
}
|
|
else if ((nroAddress & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidAddress;
|
|
}
|
|
|
|
uint magic = _owner.CpuMemory.Read<uint>(nroAddress + 0x10);
|
|
uint nroFileSize = _owner.CpuMemory.Read<uint>(nroAddress + 0x18);
|
|
|
|
if (magic != NroMagic || nroSize != nroFileSize)
|
|
{
|
|
return ResultCode.InvalidNro;
|
|
}
|
|
|
|
byte[] nroData = new byte[nroSize];
|
|
|
|
_owner.CpuMemory.Read(nroAddress, nroData);
|
|
|
|
byte[] nroHash = null;
|
|
|
|
MemoryStream stream = new MemoryStream(nroData);
|
|
|
|
using (SHA256 hasher = SHA256.Create())
|
|
{
|
|
nroHash = hasher.ComputeHash(stream);
|
|
}
|
|
|
|
if (!IsNroHashPresent(nroHash))
|
|
{
|
|
return ResultCode.NotRegistered;
|
|
}
|
|
|
|
if (IsNroLoaded(nroHash))
|
|
{
|
|
return ResultCode.AlreadyLoaded;
|
|
}
|
|
|
|
stream.Position = 0;
|
|
|
|
NroExecutable nro = new NroExecutable(stream.AsStorage(), nroAddress, bssAddress);
|
|
|
|
// Check if everything is page align.
|
|
if ((nro.Text.Length & 0xFFF) != 0 || (nro.Ro.Length & 0xFFF) != 0 ||
|
|
(nro.Data.Length & 0xFFF) != 0 || (nro.BssSize & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidNro;
|
|
}
|
|
|
|
// Check if everything is contiguous.
|
|
if (nro.RoOffset != nro.TextOffset + nro.Text.Length ||
|
|
nro.DataOffset != nro.RoOffset + nro.Ro.Length ||
|
|
nroFileSize != nro.DataOffset + nro.Data.Length)
|
|
{
|
|
return ResultCode.InvalidNro;
|
|
}
|
|
|
|
// Check the bss size match.
|
|
if ((ulong)nro.BssSize != bssSize)
|
|
{
|
|
return ResultCode.InvalidNro;
|
|
}
|
|
|
|
uint totalSize = (uint)nro.Text.Length + (uint)nro.Ro.Length + (uint)nro.Data.Length + nro.BssSize;
|
|
|
|
// Apply patches
|
|
context.Device.FileSystem.ModLoader.ApplyNroPatches(nro);
|
|
|
|
res = new NroInfo(
|
|
nro,
|
|
nroHash,
|
|
nroAddress,
|
|
nroSize,
|
|
bssAddress,
|
|
bssSize,
|
|
(ulong)totalSize);
|
|
|
|
return ResultCode.Success;
|
|
}
|
|
|
|
private ResultCode MapNro(KProcess process, NroInfo info, out ulong nroMappedAddress)
|
|
{
|
|
KPageTableBase memMgr = process.MemoryManager;
|
|
|
|
int retryCount = 0;
|
|
|
|
nroMappedAddress = 0;
|
|
|
|
while (retryCount++ < MaxMapRetries)
|
|
{
|
|
ResultCode result = MapCodeMemoryInProcess(process, info.NroAddress, info.NroSize, out nroMappedAddress);
|
|
|
|
if (result != ResultCode.Success)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
if (info.BssSize > 0)
|
|
{
|
|
KernelResult bssMappingResult = memMgr.MapProcessCodeMemory(nroMappedAddress + info.NroSize, info.BssAddress, info.BssSize);
|
|
|
|
if (bssMappingResult == KernelResult.InvalidMemState)
|
|
{
|
|
memMgr.UnmapProcessCodeMemory(nroMappedAddress + info.NroSize, info.BssAddress, info.BssSize);
|
|
memMgr.UnmapProcessCodeMemory(nroMappedAddress, info.NroAddress, info.NroSize);
|
|
|
|
continue;
|
|
}
|
|
else if (bssMappingResult != KernelResult.Success)
|
|
{
|
|
memMgr.UnmapProcessCodeMemory(nroMappedAddress + info.NroSize, info.BssAddress, info.BssSize);
|
|
memMgr.UnmapProcessCodeMemory(nroMappedAddress, info.NroAddress, info.NroSize);
|
|
|
|
return (ResultCode)bssMappingResult;
|
|
}
|
|
}
|
|
|
|
if (CanAddGuardRegionsInProcess(process, nroMappedAddress, info.TotalSize))
|
|
{
|
|
return ResultCode.Success;
|
|
}
|
|
}
|
|
|
|
return ResultCode.InsufficientAddressSpace;
|
|
}
|
|
|
|
private bool CanAddGuardRegionsInProcess(KProcess process, ulong baseAddress, ulong size)
|
|
{
|
|
KPageTableBase memMgr = process.MemoryManager;
|
|
|
|
KMemoryInfo memInfo = memMgr.QueryMemory(baseAddress - 1);
|
|
|
|
if (memInfo.State == MemoryState.Unmapped && baseAddress - GuardPagesSize >= memInfo.Address)
|
|
{
|
|
memInfo = memMgr.QueryMemory(baseAddress + size);
|
|
|
|
if (memInfo.State == MemoryState.Unmapped)
|
|
{
|
|
return baseAddress + size + GuardPagesSize <= memInfo.Address + memInfo.Size;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private ResultCode MapCodeMemoryInProcess(KProcess process, ulong baseAddress, ulong size, out ulong targetAddress)
|
|
{
|
|
KPageTableBase memMgr = process.MemoryManager;
|
|
|
|
targetAddress = 0;
|
|
|
|
int retryCount;
|
|
|
|
ulong addressSpacePageLimit = (memMgr.GetAddrSpaceSize() - size) >> 12;
|
|
|
|
for (retryCount = 0; retryCount < MaxMapRetries; retryCount++)
|
|
{
|
|
while (true)
|
|
{
|
|
ulong randomOffset = (ulong)(uint)_random.Next(0, (int)addressSpacePageLimit) << 12;
|
|
|
|
targetAddress = memMgr.GetAddrSpaceBaseAddr() + randomOffset;
|
|
|
|
if (memMgr.InsideAddrSpace(targetAddress, size) && !memMgr.InsideHeapRegion(targetAddress, size) && !memMgr.InsideAliasRegion(targetAddress, size))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
KernelResult result = memMgr.MapProcessCodeMemory(targetAddress, baseAddress, size);
|
|
|
|
if (result == KernelResult.InvalidMemState)
|
|
{
|
|
continue;
|
|
}
|
|
else if (result != KernelResult.Success)
|
|
{
|
|
return (ResultCode)result;
|
|
}
|
|
|
|
if (!CanAddGuardRegionsInProcess(process, targetAddress, size))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
return ResultCode.Success;
|
|
}
|
|
|
|
if (retryCount == MaxMapRetries)
|
|
{
|
|
return ResultCode.InsufficientAddressSpace;
|
|
}
|
|
|
|
return ResultCode.Success;
|
|
}
|
|
|
|
private KernelResult SetNroMemoryPermissions(KProcess process, IExecutable relocatableObject, ulong baseAddress)
|
|
{
|
|
ulong textStart = baseAddress + (ulong)relocatableObject.TextOffset;
|
|
ulong roStart = baseAddress + (ulong)relocatableObject.RoOffset;
|
|
ulong dataStart = baseAddress + (ulong)relocatableObject.DataOffset;
|
|
|
|
ulong bssStart = dataStart + (ulong)relocatableObject.Data.Length;
|
|
|
|
ulong bssEnd = BitUtils.AlignUp(bssStart + (ulong)relocatableObject.BssSize, KPageTableBase.PageSize);
|
|
|
|
process.CpuMemory.Write(textStart, relocatableObject.Text);
|
|
process.CpuMemory.Write(roStart, relocatableObject.Ro);
|
|
process.CpuMemory.Write(dataStart, relocatableObject.Data);
|
|
|
|
MemoryHelper.FillWithZeros(process.CpuMemory, bssStart, (int)(bssEnd - bssStart));
|
|
|
|
KernelResult result;
|
|
|
|
result = process.MemoryManager.SetProcessMemoryPermission(textStart, roStart - textStart, KMemoryPermission.ReadAndExecute);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
result = process.MemoryManager.SetProcessMemoryPermission(roStart, dataStart - roStart, KMemoryPermission.Read);
|
|
|
|
if (result != KernelResult.Success)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
return process.MemoryManager.SetProcessMemoryPermission(dataStart, bssEnd - dataStart, KMemoryPermission.ReadAndWrite);
|
|
}
|
|
|
|
private ResultCode RemoveNrrInfo(ulong nrrAddress)
|
|
{
|
|
foreach (NrrInfo info in _nrrInfos)
|
|
{
|
|
if (info.NrrAddress == nrrAddress)
|
|
{
|
|
_nrrInfos.Remove(info);
|
|
|
|
return ResultCode.Success;
|
|
}
|
|
}
|
|
|
|
return ResultCode.NotLoaded;
|
|
}
|
|
|
|
private ResultCode RemoveNroInfo(ulong nroMappedAddress)
|
|
{
|
|
foreach (NroInfo info in _nroInfos)
|
|
{
|
|
if (info.NroMappedAddress == nroMappedAddress)
|
|
{
|
|
_nroInfos.Remove(info);
|
|
|
|
return UnmapNroFromInfo(info);
|
|
}
|
|
}
|
|
|
|
return ResultCode.NotLoaded;
|
|
}
|
|
|
|
private ResultCode UnmapNroFromInfo(NroInfo info)
|
|
{
|
|
ulong textSize = (ulong)info.Executable.Text.Length;
|
|
ulong roSize = (ulong)info.Executable.Ro.Length;
|
|
ulong dataSize = (ulong)info.Executable.Data.Length;
|
|
ulong bssSize = (ulong)info.Executable.BssSize;
|
|
|
|
KernelResult result = KernelResult.Success;
|
|
|
|
if (info.Executable.BssSize != 0)
|
|
{
|
|
result = _owner.MemoryManager.UnmapProcessCodeMemory(
|
|
info.NroMappedAddress + textSize + roSize + dataSize,
|
|
info.Executable.BssAddress,
|
|
bssSize);
|
|
}
|
|
|
|
if (result == KernelResult.Success)
|
|
{
|
|
result = _owner.MemoryManager.UnmapProcessCodeMemory(
|
|
info.NroMappedAddress + textSize + roSize,
|
|
info.Executable.SourceAddress + textSize + roSize,
|
|
dataSize);
|
|
|
|
if (result == KernelResult.Success)
|
|
{
|
|
result = _owner.MemoryManager.UnmapProcessCodeMemory(
|
|
info.NroMappedAddress,
|
|
info.Executable.SourceAddress,
|
|
textSize + roSize);
|
|
}
|
|
}
|
|
|
|
return (ResultCode)result;
|
|
}
|
|
|
|
private ResultCode IsInitialized(long pid)
|
|
{
|
|
if (_owner != null && _owner.Pid == pid)
|
|
{
|
|
return ResultCode.Success;
|
|
}
|
|
|
|
return ResultCode.InvalidProcess;
|
|
}
|
|
|
|
[CommandHipc(0)]
|
|
// LoadNro(u64, u64, u64, u64, u64, pid) -> u64
|
|
public ResultCode LoadNro(ServiceCtx context)
|
|
{
|
|
ResultCode result = IsInitialized(_owner.Pid);
|
|
|
|
// Zero
|
|
context.RequestData.ReadUInt64();
|
|
|
|
ulong nroHeapAddress = context.RequestData.ReadUInt64();
|
|
ulong nroSize = context.RequestData.ReadUInt64();
|
|
ulong bssHeapAddress = context.RequestData.ReadUInt64();
|
|
ulong bssSize = context.RequestData.ReadUInt64();
|
|
|
|
ulong nroMappedAddress = 0;
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
NroInfo info;
|
|
|
|
result = ParseNro(out info, context, nroHeapAddress, nroSize, bssHeapAddress, bssSize);
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
result = MapNro(_owner, info, out nroMappedAddress);
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
result = (ResultCode)SetNroMemoryPermissions(_owner, info.Executable, nroMappedAddress);
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
info.NroMappedAddress = nroMappedAddress;
|
|
|
|
_nroInfos.Add(info);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
context.ResponseData.Write(nroMappedAddress);
|
|
|
|
return result;
|
|
}
|
|
|
|
[CommandHipc(1)]
|
|
// UnloadNro(u64, u64, pid)
|
|
public ResultCode UnloadNro(ServiceCtx context)
|
|
{
|
|
ResultCode result = IsInitialized(_owner.Pid);
|
|
|
|
// Zero
|
|
context.RequestData.ReadUInt64();
|
|
|
|
ulong nroMappedAddress = context.RequestData.ReadUInt64();
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
if ((nroMappedAddress & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidAddress;
|
|
}
|
|
|
|
result = RemoveNroInfo(nroMappedAddress);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[CommandHipc(2)]
|
|
// LoadNrr(u64, u64, u64, pid)
|
|
public ResultCode LoadNrr(ServiceCtx context)
|
|
{
|
|
ResultCode result = IsInitialized(_owner.Pid);
|
|
|
|
// pid placeholder, zero
|
|
context.RequestData.ReadUInt64();
|
|
|
|
ulong nrrAddress = context.RequestData.ReadUInt64();
|
|
ulong nrrSize = context.RequestData.ReadUInt64();
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
NrrInfo info;
|
|
result = ParseNrr(out info, context, nrrAddress, nrrSize);
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
if (_nrrInfos.Count >= MaxNrr)
|
|
{
|
|
result = ResultCode.NotLoaded;
|
|
}
|
|
else
|
|
{
|
|
_nrrInfos.Add(info);
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[CommandHipc(3)]
|
|
// UnloadNrr(u64, u64, pid)
|
|
public ResultCode UnloadNrr(ServiceCtx context)
|
|
{
|
|
ResultCode result = IsInitialized(_owner.Pid);
|
|
|
|
// pid placeholder, zero
|
|
context.RequestData.ReadUInt64();
|
|
|
|
ulong nrrHeapAddress = context.RequestData.ReadUInt64();
|
|
|
|
if (result == ResultCode.Success)
|
|
{
|
|
if ((nrrHeapAddress & 0xFFF) != 0)
|
|
{
|
|
return ResultCode.InvalidAddress;
|
|
}
|
|
|
|
result = RemoveNrrInfo(nrrHeapAddress);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[CommandHipc(4)]
|
|
// Initialize(u64, pid, KObject)
|
|
public ResultCode Initialize(ServiceCtx context)
|
|
{
|
|
if (_owner != null)
|
|
{
|
|
return ResultCode.InvalidSession;
|
|
}
|
|
|
|
_owner = context.Process.HandleTable.GetKProcess(context.Request.HandleDesc.ToCopy[0]);
|
|
context.Device.System.KernelContext.Syscall.CloseHandle(context.Request.HandleDesc.ToCopy[0]);
|
|
|
|
return ResultCode.Success;
|
|
}
|
|
|
|
protected override void Dispose(bool isDisposing)
|
|
{
|
|
if (isDisposing)
|
|
{
|
|
foreach (NroInfo info in _nroInfos)
|
|
{
|
|
UnmapNroFromInfo(info);
|
|
}
|
|
|
|
_nroInfos.Clear();
|
|
}
|
|
}
|
|
}
|
|
} |