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>
author: Ac_K <Acoustik666@gmail.com> 2023-03-31 21:16:46 +0200
committer: GitHub <noreply@github.com> 2023-03-31 21:16:46 +0200
commit: 4c2d9ff3ff9d7afb1fd0bd764bee5931fa5f053c (patch)
tree: 1245f5ec356551bd20a9594d114d06a53c41d036 /Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs
parent: 8198b99935f562ffb2fb9a75175a8df24d235152 (diff)
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
author	Ac_K <Acoustik666@gmail.com>	2023-03-31 21:16:46 +0200
committer	GitHub <noreply@github.com>	2023-03-31 21:16:46 +0200
commit	4c2d9ff3ff9d7afb1fd0bd764bee5931fa5f053c (patch)
tree	1245f5ec356551bd20a9594d114d06a53c41d036 /Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs
parent	8198b99935f562ffb2fb9a75175a8df24d235152 (diff)