aboutsummaryrefslogtreecommitdiff
path: root/Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs
diff options
context:
space:
mode:
authorAc_K <Acoustik666@gmail.com>2023-03-31 21:16:46 +0200
committerGitHub <noreply@github.com>2023-03-31 21:16:46 +0200
commit4c2d9ff3ff9d7afb1fd0bd764bee5931fa5f053c (patch)
tree1245f5ec356551bd20a9594d114d06a53c41d036 /Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs
parent8198b99935f562ffb2fb9a75175a8df24d235152 (diff)
HLE: Refactoring of ApplicationLoader (#4480)1.1.689
* HLE: Refactoring of ApplicationLoader * Fix SDL2 Headless * Addresses gdkchan feedback * Fixes LoadUnpackedNca RomFS loading * remove useless casting * Cleanup and fixe empty application name * Remove ProcessInfo * Fixes typo * ActiveProcess to ActiveApplication * Update check * Clean using. * Use the correct filepath when loading Homebrew.npdm * Fix NRE in ProcessResult if MetaLoader is null * Add more checks for valid processId & return success * Add missing logging statement for npdm error * Return result for LoadKip() * Move error logging out of PFS load extension method This avoids logging "Could not find Main NCA" followed by "Loading main..." when trying to start hbl. * Fix GUIs not checking load results * Fix style and formatting issues * Fix formatting and wording * gtk: Refactor LoadApplication() --------- Co-authored-by: TSR Berry <20988865+TSRBerry@users.noreply.github.com>
Diffstat (limited to 'Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs')
-rw-r--r--Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs458
1 files changed, 458 insertions, 0 deletions
diff --git a/Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs b/Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs
new file mode 100644
index 00000000..7176445e
--- /dev/null
+++ b/Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs
@@ -0,0 +1,458 @@
+using LibHac.Account;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Shim;
+using LibHac.FsSystem;
+using LibHac.Loader;
+using LibHac.Ncm;
+using LibHac.Ns;
+using LibHac.Tools.Fs;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS;
+using Ryujinx.HLE.HOS.Kernel;
+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.Loaders.Processes.Extensions;
+using Ryujinx.Horizon.Common;
+using System;
+using System.Linq;
+using System.Runtime.InteropServices;
+using ApplicationId = LibHac.Ncm.ApplicationId;
+
+namespace Ryujinx.HLE.Loaders.Processes
+{
+ static class ProcessLoaderHelper
+ {
+ public static LibHac.Result RegisterProgramMapInfo(Switch device, PartitionFileSystem partitionFileSystem)
+ {
+ ulong applicationId = 0;
+ int programCount = 0;
+
+ Span<bool> hasIndex = stackalloc bool[0x10];
+
+ foreach (DirectoryEntryEx fileEntry in partitionFileSystem.EnumerateEntries("/", "*.nca"))
+ {
+ Nca nca = partitionFileSystem.GetNca(device, fileEntry.FullPath);
+
+ if (!nca.IsProgram() && nca.IsPatch())
+ {
+ continue;
+ }
+
+ ulong currentProgramId = nca.Header.TitleId;
+ ulong currentMainProgramId = currentProgramId & ~0xFFFul;
+
+ if (applicationId == 0 && currentMainProgramId != 0)
+ {
+ applicationId = currentMainProgramId;
+ }
+
+ if (applicationId != currentMainProgramId)
+ {
+ // Currently there aren't any known multi-application game cards containing multi-program applications,
+ // so because multi-application game cards are the only way we could run into multiple applications
+ // we'll just return that there's a single program.
+ programCount = 1;
+
+ break;
+ }
+
+ hasIndex[(int)(currentProgramId & 0xF)] = true;
+ }
+
+ if (programCount == 0)
+ {
+ for (int i = 0; i < hasIndex.Length && hasIndex[i]; i++)
+ {
+ programCount++;
+ }
+ }
+
+ if (programCount <= 0)
+ {
+ return LibHac.Result.Success;
+ }
+
+ Span<ProgramIndexMapInfo> mapInfo = stackalloc ProgramIndexMapInfo[0x10];
+
+ for (int i = 0; i < programCount; i++)
+ {
+ mapInfo[i].ProgramId = new ProgramId(applicationId + (uint)i);
+ mapInfo[i].MainProgramId = new ApplicationId(applicationId);
+ mapInfo[i].ProgramIndex = (byte)i;
+ }
+
+ return device.System.LibHacHorizonManager.NsClient.Fs.RegisterProgramIndexMapInfo(mapInfo[..programCount]);
+ }
+
+ public static LibHac.Result EnsureSaveData(Switch device, ApplicationId applicationId, BlitStruct<ApplicationControlProperty> applicationControlProperty)
+ {
+ Logger.Info?.Print(LogClass.Application, "Ensuring required savedata exists.");
+
+ ref ApplicationControlProperty control = ref applicationControlProperty.Value;
+
+ if (LibHac.Common.Utilities.IsZeros(applicationControlProperty.ByteSpan))
+ {
+ // If the current application doesn't have a loaded control property, create a dummy one and set the savedata sizes so a user savedata will be created.
+ control = ref new BlitStruct<ApplicationControlProperty>(1).Value;
+
+ // The set sizes don't actually matter as long as they're non-zero because we use directory savedata.
+ control.UserAccountSaveDataSize = 0x4000;
+ control.UserAccountSaveDataJournalSize = 0x4000;
+ control.SaveDataOwnerId = applicationId.Value;
+
+ Logger.Warning?.Print(LogClass.Application, "No control file was found for this game. Using a dummy one instead. This may cause inaccuracies in some games.");
+ }
+
+ LibHac.Result resultCode = device.System.LibHacHorizonManager.RyujinxClient.Fs.EnsureApplicationCacheStorage(out _, out _, applicationId, in control);
+ if (resultCode.IsFailure())
+ {
+ Logger.Error?.Print(LogClass.Application, $"Error calling EnsureApplicationCacheStorage. Result code {resultCode.ToStringWithName()}");
+
+ return resultCode;
+ }
+
+ Uid userId = device.System.AccountManager.LastOpenedUser.UserId.ToLibHacUid();
+
+ resultCode = device.System.LibHacHorizonManager.RyujinxClient.Fs.EnsureApplicationSaveData(out _, applicationId, in control, in userId);
+ if (resultCode.IsFailure())
+ {
+ Logger.Error?.Print(LogClass.Application, $"Error calling EnsureApplicationSaveData. Result code {resultCode.ToStringWithName()}");
+ }
+
+ return resultCode;
+ }
+
+ public static bool LoadKip(KernelContext context, KipExecutable kip)
+ {
+ uint endOffset = kip.DataOffset + (uint)kip.Data.Length;
+
+ if (kip.BssSize != 0)
+ {
+ endOffset = kip.BssOffset + kip.BssSize;
+ }
+
+ uint codeSize = BitUtils.AlignUp<uint>(kip.TextOffset + endOffset, KPageTableBase.PageSize);
+ int codePagesCount = (int)(codeSize / KPageTableBase.PageSize);
+ ulong codeBaseAddress = kip.Is64BitAddressSpace ? 0x8000000UL : 0x200000UL;
+ ulong codeAddress = codeBaseAddress + kip.TextOffset;
+
+ ProcessCreationFlags flags = 0;
+
+ if (ProcessConst.AslrEnabled)
+ {
+ // TODO: Randomization.
+
+ flags |= ProcessCreationFlags.EnableAslr;
+ }
+
+ if (kip.Is64BitAddressSpace)
+ {
+ flags |= ProcessCreationFlags.AddressSpace64Bit;
+ }
+
+ if (kip.Is64Bit)
+ {
+ flags |= ProcessCreationFlags.Is64Bit;
+ }
+
+ ProcessCreationInfo creationInfo = new(kip.Name, kip.Version, kip.ProgramId, codeAddress, codePagesCount, flags, 0, 0);
+ MemoryRegion memoryRegion = kip.UsesSecureMemory ? MemoryRegion.Service : MemoryRegion.Application;
+ KMemoryRegionManager region = context.MemoryManager.MemoryRegions[(int)memoryRegion];
+
+ Result result = region.AllocatePages(out KPageList pageList, (ulong)codePagesCount);
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
+
+ return false;
+ }
+
+ KProcess process = new(context);
+
+ var processContextFactory = new ArmProcessContextFactory(
+ context.Device.System.TickSource,
+ context.Device.Gpu,
+ string.Empty,
+ string.Empty,
+ false,
+ codeAddress,
+ codeSize);
+
+ result = process.InitializeKip(creationInfo, kip.Capabilities, pageList, context.ResourceLimit, memoryRegion, processContextFactory);
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
+
+ return false;
+ }
+
+ result = LoadIntoMemory(process, kip, codeBaseAddress);
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
+
+ return false;
+ }
+
+ process.DefaultCpuCore = kip.IdealCoreId;
+
+ result = process.Start(kip.Priority, (ulong)kip.StackSize);
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process start returned error \"{result}\".");
+
+ return false;
+ }
+
+ context.Processes.TryAdd(process.Pid, process);
+
+ return true;
+ }
+
+ public static ProcessResult LoadNsos(
+ Switch device,
+ KernelContext context,
+ MetaLoader metaLoader,
+ ApplicationControlProperty applicationControlProperties,
+ bool diskCacheEnabled,
+ bool allowCodeMemoryForJit,
+ string name,
+ ulong programId,
+ byte[] arguments = null,
+ params IExecutable[] executables)
+ {
+ context.Device.System.ServiceTable.WaitServicesReady();
+
+ LibHac.Result resultCode = metaLoader.GetNpdm(out var npdm);
+
+ if (resultCode.IsFailure())
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization failed getting npdm. Result Code {resultCode.ToStringWithName()}");
+
+ return ProcessResult.Failed;
+ }
+
+ ref readonly var meta = ref npdm.Meta;
+
+ ulong argsStart = 0;
+ uint argsSize = 0;
+ ulong codeStart = (meta.Flags & 1) != 0 ? 0x8000000UL : 0x200000UL;
+ uint codeSize = 0;
+
+ var buildIds = executables.Select(e => (e switch
+ {
+ NsoExecutable nso => Convert.ToHexString(nso.BuildId.ItemsRo.ToArray()),
+ NroExecutable nro => Convert.ToHexString(nro.Header.BuildId),
+ _ => ""
+ }).ToUpper());
+
+ ulong[] nsoBase = new ulong[executables.Length];
+
+ for (int index = 0; index < executables.Length; index++)
+ {
+ IExecutable nso = executables[index];
+
+ uint textEnd = nso.TextOffset + (uint)nso.Text.Length;
+ uint roEnd = nso.RoOffset + (uint)nso.Ro.Length;
+ uint dataEnd = nso.DataOffset + (uint)nso.Data.Length + nso.BssSize;
+
+ uint nsoSize = textEnd;
+
+ if (nsoSize < roEnd)
+ {
+ nsoSize = roEnd;
+ }
+
+ if (nsoSize < dataEnd)
+ {
+ nsoSize = dataEnd;
+ }
+
+ nsoSize = BitUtils.AlignUp<uint>(nsoSize, KPageTableBase.PageSize);
+
+ nsoBase[index] = codeStart + codeSize;
+
+ codeSize += nsoSize;
+
+ if (arguments != null && argsSize == 0)
+ {
+ argsStart = codeSize;
+
+ argsSize = (uint)BitUtils.AlignDown(arguments.Length * 2 + ProcessConst.NsoArgsTotalSize - 1, KPageTableBase.PageSize);
+
+ codeSize += argsSize;
+ }
+ }
+
+ int codePagesCount = (int)(codeSize / KPageTableBase.PageSize);
+ int personalMmHeapPagesCount = (int)(meta.SystemResourceSize / KPageTableBase.PageSize);
+
+ ProcessCreationInfo creationInfo = new(
+ name,
+ (int)meta.Version,
+ programId,
+ codeStart,
+ codePagesCount,
+ (ProcessCreationFlags)meta.Flags | ProcessCreationFlags.IsApplication,
+ 0,
+ personalMmHeapPagesCount);
+
+ context.Device.System.LibHacHorizonManager.InitializeApplicationClient(new ProgramId(programId), in npdm);
+
+ Result result;
+
+ KResourceLimit resourceLimit = new(context);
+
+ long applicationRgSize = (long)context.MemoryManager.MemoryRegions[(int)MemoryRegion.Application].Size;
+
+ result = resourceLimit.SetLimitValue(LimitableResource.Memory, applicationRgSize);
+
+ if (result.IsSuccess)
+ {
+ result = resourceLimit.SetLimitValue(LimitableResource.Thread, 608);
+ }
+
+ if (result.IsSuccess)
+ {
+ result = resourceLimit.SetLimitValue(LimitableResource.Event, 700);
+ }
+
+ if (result.IsSuccess)
+ {
+ result = resourceLimit.SetLimitValue(LimitableResource.TransferMemory, 128);
+ }
+
+ if (result.IsSuccess)
+ {
+ result = resourceLimit.SetLimitValue(LimitableResource.Session, 894);
+ }
+
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization failed setting resource limit values.");
+
+ return ProcessResult.Failed;
+ }
+
+ KProcess process = new(context, allowCodeMemoryForJit);
+
+ // NOTE: This field doesn't exists one firmware pre-5.0.0, a workaround have to be found.
+ MemoryRegion memoryRegion = (MemoryRegion)(npdm.Acid.Flags >> 2 & 0xf);
+ if (memoryRegion > MemoryRegion.NvServices)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization failed due to invalid ACID flags.");
+
+ return ProcessResult.Failed;
+ }
+
+ var processContextFactory = new ArmProcessContextFactory(
+ context.Device.System.TickSource,
+ context.Device.Gpu,
+ $"{programId:x16}",
+ applicationControlProperties.DisplayVersionString.ToString(),
+ diskCacheEnabled,
+ codeStart,
+ codeSize);
+
+ result = process.Initialize(
+ creationInfo,
+ MemoryMarshal.Cast<byte, uint>(npdm.KernelCapabilityData),
+ resourceLimit,
+ memoryRegion,
+ processContextFactory);
+
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
+
+ return ProcessResult.Failed;
+ }
+
+ for (int index = 0; index < executables.Length; index++)
+ {
+ Logger.Info?.Print(LogClass.Loader, $"Loading image {index} at 0x{nsoBase[index]:x16}...");
+
+ result = LoadIntoMemory(process, executables[index], nsoBase[index]);
+ if (result != Result.Success)
+ {
+ Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
+
+ return ProcessResult.Failed;
+ }
+ }
+
+ process.DefaultCpuCore = meta.DefaultCpuId;
+
+ context.Processes.TryAdd(process.Pid, process);
+
+ // Keep the build ids because the tamper machine uses them to know which process to associate a
+ // tamper to and also keep the starting address of each executable inside a process because some
+ // memory modifications are relative to this address.
+ ProcessTamperInfo tamperInfo = new(
+ process,
+ buildIds,
+ nsoBase,
+ process.MemoryManager.HeapRegionStart,
+ process.MemoryManager.AliasRegionStart,
+ process.MemoryManager.CodeRegionStart);
+
+ // Once everything is loaded, we can load cheats.
+ device.Configuration.VirtualFileSystem.ModLoader.LoadCheats(programId, tamperInfo, device.TamperMachine);
+
+ return new ProcessResult(metaLoader, applicationControlProperties, diskCacheEnabled, allowCodeMemoryForJit, processContextFactory.DiskCacheLoadState, process.Pid, meta.MainThreadPriority, meta.MainThreadStackSize);
+ }
+
+ public static Result LoadIntoMemory(KProcess process, IExecutable image, ulong baseAddress)
+ {
+ ulong textStart = baseAddress + image.TextOffset;
+ ulong roStart = baseAddress + image.RoOffset;
+ ulong dataStart = baseAddress + image.DataOffset;
+ ulong bssStart = baseAddress + image.BssOffset;
+
+ ulong end = dataStart + (ulong)image.Data.Length;
+
+ if (image.BssSize != 0)
+ {
+ end = bssStart + image.BssSize;
+ }
+
+ process.CpuMemory.Write(textStart, image.Text);
+ process.CpuMemory.Write(roStart, image.Ro);
+ process.CpuMemory.Write(dataStart, image.Data);
+
+ process.CpuMemory.Fill(bssStart, image.BssSize, 0);
+
+ Result SetProcessMemoryPermission(ulong address, ulong size, KMemoryPermission permission)
+ {
+ if (size == 0)
+ {
+ return Result.Success;
+ }
+
+ size = BitUtils.AlignUp<ulong>(size, KPageTableBase.PageSize);
+
+ return process.MemoryManager.SetProcessMemoryPermission(address, size, permission);
+ }
+
+ Result result = SetProcessMemoryPermission(textStart, (ulong)image.Text.Length, KMemoryPermission.ReadAndExecute);
+ if (result != Result.Success)
+ {
+ return result;
+ }
+
+ result = SetProcessMemoryPermission(roStart, (ulong)image.Ro.Length, KMemoryPermission.Read);
+ if (result != Result.Success)
+ {
+ return result;
+ }
+
+ return SetProcessMemoryPermission(dataStart, end - dataStart, KMemoryPermission.ReadAndWrite);
+ }
+ }
+} \ No newline at end of file