public static bool LoadKernelInitalProcess(Horizon system, KernelInitialProcess kip)
{
int endOffset = kip.DataOffset + kip.Data.Length;
if (kip.BssSize != 0)
{
endOffset = kip.BssOffset + kip.BssSize;
}
int codeSize = BitUtils.AlignUp(kip.TextOffset + endOffset, KMemoryManager.PageSize);
int codePagesCount = codeSize / KMemoryManager.PageSize;
ulong codeBaseAddress = kip.Addr39Bits ? 0x8000000UL : 0x200000UL;
ulong codeAddress = codeBaseAddress + (ulong)kip.TextOffset;
int mmuFlags = 0;
if (AslrEnabled)
{
//TODO: Randomization.
mmuFlags |= 0x20;
}
if (kip.Addr39Bits)
{
mmuFlags |= (int)AddressSpaceType.Addr39Bits << 1;
}
if (kip.Is64Bits)
{
mmuFlags |= 1;
}
ProcessCreationInfo creationInfo = new ProcessCreationInfo(
kip.Name,
kip.ProcessCategory,
kip.TitleId,
codeAddress,
codePagesCount,
mmuFlags,
0,
0);
MemoryRegion memRegion = kip.IsService
? MemoryRegion.Service
: MemoryRegion.Application;
KMemoryRegionManager region = system.MemoryRegions[(int)memRegion];
KernelResult result = region.AllocatePages((ulong)codePagesCount, false, out KPageList pageList);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
KProcess process = new KProcess(system);
result = process.InitializeKip(
creationInfo,
kip.Capabilities,
pageList,
system.ResourceLimit,
memRegion);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
result = LoadIntoMemory(process, kip, codeBaseAddress);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
result = process.Start(kip.MainThreadPriority, (ulong)kip.MainThreadStackSize);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process start returned error \"{result}\".");
return(false);
}
system.Processes.Add(process.Pid, process);
return(true);
}
public static bool LoadStaticObjects(
Horizon system,
Npdm metaData,
IExecutable[] staticObjects,
byte[] arguments = null)
{
ulong argsStart = 0;
int argsSize = 0;
ulong codeStart = 0x8000000;
int codeSize = 0;
ulong[] nsoBase = new ulong[staticObjects.Length];
for (int index = 0; index < staticObjects.Length; index++)
{
IExecutable staticObject = staticObjects[index];
int textEnd = staticObject.TextOffset + staticObject.Text.Length;
int roEnd = staticObject.RoOffset + staticObject.Ro.Length;
int dataEnd = staticObject.DataOffset + staticObject.Data.Length + staticObject.BssSize;
int nsoSize = textEnd;
if ((uint)nsoSize < (uint)roEnd)
{
nsoSize = roEnd;
}
if ((uint)nsoSize < (uint)dataEnd)
{
nsoSize = dataEnd;
}
nsoSize = BitUtils.AlignUp(nsoSize, KMemoryManager.PageSize);
nsoBase[index] = codeStart + (ulong)codeSize;
codeSize += nsoSize;
if (arguments != null && argsSize == 0)
{
argsStart = (ulong)codeSize;
argsSize = BitUtils.AlignDown(arguments.Length * 2 + ArgsTotalSize - 1, KMemoryManager.PageSize);
codeSize += argsSize;
}
}
int codePagesCount = codeSize / KMemoryManager.PageSize;
int personalMmHeapPagesCount = metaData.PersonalMmHeapSize / KMemoryManager.PageSize;
ProcessCreationInfo creationInfo = new ProcessCreationInfo(
metaData.TitleName,
metaData.ProcessCategory,
metaData.Aci0.TitleId,
codeStart,
codePagesCount,
metaData.MmuFlags,
0,
personalMmHeapPagesCount);
KernelResult result;
KResourceLimit resourceLimit = new KResourceLimit(system);
long applicationRgSize = (long)system.MemoryRegions[(int)MemoryRegion.Application].Size;
result = resourceLimit.SetLimitValue(LimitableResource.Memory, applicationRgSize);
result |= resourceLimit.SetLimitValue(LimitableResource.Thread, 608);
result |= resourceLimit.SetLimitValue(LimitableResource.Event, 700);
result |= resourceLimit.SetLimitValue(LimitableResource.TransferMemory, 128);
result |= resourceLimit.SetLimitValue(LimitableResource.Session, 894);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization failed setting resource limit values.");
return(false);
}
KProcess process = new KProcess(system);
result = process.Initialize(
creationInfo,
metaData.Aci0.KernelAccessControl.Capabilities,
resourceLimit,
MemoryRegion.Application);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
for (int index = 0; index < staticObjects.Length; index++)
{
Logger.PrintInfo(LogClass.Loader, $"Loading image {index} at 0x{nsoBase[index]:x16}...");
result = LoadIntoMemory(process, staticObjects[index], nsoBase[index]);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
}
result = process.Start(metaData.MainThreadPriority, (ulong)metaData.MainThreadStackSize);
if (result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process start returned error \"{result}\".");
return(false);
}
system.Processes.Add(process.Pid, process);
return(true);
}
public static bool LoadKip(KernelContext context, KipExecutable kip)
{
int endOffset = kip.DataOffset + kip.Data.Length;
if (kip.BssSize != 0)
{
endOffset = kip.BssOffset + kip.BssSize;
}
int codeSize = BitUtils.AlignUp(kip.TextOffset + endOffset, KMemoryManager.PageSize);
int codePagesCount = codeSize / KMemoryManager.PageSize;
ulong codeBaseAddress = kip.Is64BitAddressSpace ? 0x8000000UL : 0x200000UL;
ulong codeAddress = codeBaseAddress + (ulong)kip.TextOffset;
ProcessCreationFlags flags = 0;
if (AslrEnabled)
{
// TODO: Randomization.
flags |= ProcessCreationFlags.EnableAslr;
}
if (kip.Is64BitAddressSpace)
{
flags |= ProcessCreationFlags.AddressSpace64Bit;
}
if (kip.Is64Bit)
{
flags |= ProcessCreationFlags.Is64Bit;
}
ProcessCreationInfo creationInfo = new ProcessCreationInfo(
kip.Name,
kip.Version,
kip.ProgramId,
codeAddress,
codePagesCount,
flags,
0,
0);
MemoryRegion memoryRegion = kip.UsesSecureMemory
? MemoryRegion.Service
: MemoryRegion.Application;
KMemoryRegionManager region = context.MemoryRegions[(int)memoryRegion];
KernelResult result = region.AllocatePages((ulong)codePagesCount, false, out KPageList pageList);
if (result != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
KProcess process = new KProcess(context);
var processContextFactory = new ArmProcessContextFactory();
result = process.InitializeKip(
creationInfo,
kip.Capabilities,
pageList,
context.ResourceLimit,
memoryRegion,
processContextFactory);
if (result != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
result = LoadIntoMemory(process, kip, codeBaseAddress);
if (result != KernelResult.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 != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process start returned error \"{result}\".");
return(false);
}
context.Processes.TryAdd(process.Pid, process);
return(true);
}
public static bool LoadNsos(
KernelContext context,
Npdm metaData,
byte[] arguments = null,
params IExecutable[] executables)
{
ulong argsStart = 0;
int argsSize = 0;
ulong codeStart = metaData.Is64Bit ? 0x8000000UL : 0x200000UL;
int codeSize = 0;
ulong[] nsoBase = new ulong[executables.Length];
for (int index = 0; index < executables.Length; index++)
{
IExecutable staticObject = executables[index];
int textEnd = staticObject.TextOffset + staticObject.Text.Length;
int roEnd = staticObject.RoOffset + staticObject.Ro.Length;
int dataEnd = staticObject.DataOffset + staticObject.Data.Length + staticObject.BssSize;
int nsoSize = textEnd;
if ((uint)nsoSize < (uint)roEnd)
{
nsoSize = roEnd;
}
if ((uint)nsoSize < (uint)dataEnd)
{
nsoSize = dataEnd;
}
nsoSize = BitUtils.AlignUp(nsoSize, KMemoryManager.PageSize);
nsoBase[index] = codeStart + (ulong)codeSize;
codeSize += nsoSize;
if (arguments != null && argsSize == 0)
{
argsStart = (ulong)codeSize;
argsSize = BitUtils.AlignDown(arguments.Length * 2 + ArgsTotalSize - 1, KMemoryManager.PageSize);
codeSize += argsSize;
}
}
PtcProfiler.StaticCodeStart = codeStart;
PtcProfiler.StaticCodeSize = codeSize;
int codePagesCount = codeSize / KMemoryManager.PageSize;
int personalMmHeapPagesCount = metaData.PersonalMmHeapSize / KMemoryManager.PageSize;
ProcessCreationInfo creationInfo = new ProcessCreationInfo(
metaData.TitleName,
metaData.Version,
metaData.Aci0.TitleId,
codeStart,
codePagesCount,
(ProcessCreationFlags)metaData.ProcessFlags | ProcessCreationFlags.IsApplication,
0,
personalMmHeapPagesCount);
KernelResult result;
KResourceLimit resourceLimit = new KResourceLimit(context);
long applicationRgSize = (long)context.MemoryRegions[(int)MemoryRegion.Application].Size;
result = resourceLimit.SetLimitValue(LimitableResource.Memory, applicationRgSize);
result |= resourceLimit.SetLimitValue(LimitableResource.Thread, 608);
result |= resourceLimit.SetLimitValue(LimitableResource.Event, 700);
result |= resourceLimit.SetLimitValue(LimitableResource.TransferMemory, 128);
result |= resourceLimit.SetLimitValue(LimitableResource.Session, 894);
if (result != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process initialization failed setting resource limit values.");
return(false);
}
KProcess process = new KProcess(context);
MemoryRegion memoryRegion = (MemoryRegion)((metaData.Acid.Flags >> 2) & 0xf);
if (memoryRegion > MemoryRegion.NvServices)
{
Logger.Error?.Print(LogClass.Loader, $"Process initialization failed due to invalid ACID flags.");
return(false);
}
var processContextFactory = new ArmProcessContextFactory();
result = process.Initialize(
creationInfo,
metaData.Aci0.KernelAccessControl.Capabilities,
resourceLimit,
memoryRegion,
processContextFactory);
if (result != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
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 != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process initialization returned error \"{result}\".");
return(false);
}
}
process.DefaultCpuCore = metaData.DefaultCpuId;
result = process.Start(metaData.MainThreadPriority, (ulong)metaData.MainThreadStackSize);
if (result != KernelResult.Success)
{
Logger.Error?.Print(LogClass.Loader, $"Process start returned error \"{result}\".");
return(false);
}
context.Processes.TryAdd(process.Pid, process);
return(true);
}
public static bool LoadKernelInitalProcess(Horizon System, KernelInitialProcess Kip)
{
int EndOffset = Kip.DataOffset + Kip.Data.Length;
if (Kip.BssSize != 0)
{
EndOffset = Kip.BssOffset + Kip.BssSize;
}
int CodeSize = BitUtils.AlignUp(Kip.TextOffset + EndOffset, KMemoryManager.PageSize);
int CodePagesCount = CodeSize / KMemoryManager.PageSize;
ulong CodeBaseAddress = Kip.Addr39Bits ? 0x8000000UL : 0x200000UL;
ulong CodeAddress = CodeBaseAddress + (ulong)Kip.TextOffset;
int MmuFlags = 0;
if (AslrEnabled)
{
//TODO: Randomization.
MmuFlags |= 0x20;
}
if (Kip.Addr39Bits)
{
MmuFlags |= (int)AddressSpaceType.Addr39Bits << 1;
}
if (Kip.Is64Bits)
{
MmuFlags |= 1;
}
ProcessCreationInfo CreationInfo = new ProcessCreationInfo(
Kip.Name,
Kip.ProcessCategory,
Kip.TitleId,
CodeAddress,
CodePagesCount,
MmuFlags,
0,
0);
MemoryRegion MemRegion = Kip.IsService
? MemoryRegion.Service
: MemoryRegion.Application;
KMemoryRegionManager Region = System.MemoryRegions[(int)MemRegion];
KernelResult Result = Region.AllocatePages((ulong)CodePagesCount, false, out KPageList PageList);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
return(false);
}
KProcess Process = new KProcess(System);
Result = Process.InitializeKip(
CreationInfo,
Kip.Capabilities,
PageList,
System.ResourceLimit,
MemRegion);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
return(false);
}
Result = LoadIntoMemory(Process, Kip, CodeBaseAddress);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
return(false);
}
Result = Process.Start(Kip.MainThreadPriority, (ulong)Kip.MainThreadStackSize);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process start returned error \"{Result}\".");
return(false);
}
System.Processes.Add(Process.Pid, Process);
return(true);
}
public static bool LoadStaticObjects(
Horizon System,
Npdm MetaData,
IExecutable[] StaticObjects,
byte[] Arguments = null)
{
ulong ArgsStart = 0;
int ArgsSize = 0;
ulong CodeStart = 0x8000000;
int CodeSize = 0;
ulong[] NsoBase = new ulong[StaticObjects.Length];
for (int Index = 0; Index < StaticObjects.Length; Index++)
{
IExecutable StaticObject = StaticObjects[Index];
int TextEnd = StaticObject.TextOffset + StaticObject.Text.Length;
int ROEnd = StaticObject.ROOffset + StaticObject.RO.Length;
int DataEnd = StaticObject.DataOffset + StaticObject.Data.Length + StaticObject.BssSize;
int NsoSize = TextEnd;
if ((uint)NsoSize < (uint)ROEnd)
{
NsoSize = ROEnd;
}
if ((uint)NsoSize < (uint)DataEnd)
{
NsoSize = DataEnd;
}
NsoSize = BitUtils.AlignUp(NsoSize, KMemoryManager.PageSize);
NsoBase[Index] = CodeStart + (ulong)CodeSize;
CodeSize += NsoSize;
if (Arguments != null && ArgsSize == 0)
{
ArgsStart = (ulong)CodeSize;
ArgsSize = BitUtils.AlignDown(Arguments.Length * 2 + ArgsTotalSize - 1, KMemoryManager.PageSize);
CodeSize += ArgsSize;
}
}
int CodePagesCount = CodeSize / KMemoryManager.PageSize;
int PersonalMmHeapPagesCount = MetaData.PersonalMmHeapSize / KMemoryManager.PageSize;
ProcessCreationInfo CreationInfo = new ProcessCreationInfo(
MetaData.TitleName,
MetaData.ProcessCategory,
MetaData.ACI0.TitleId,
CodeStart,
CodePagesCount,
MetaData.MmuFlags,
0,
PersonalMmHeapPagesCount);
KernelResult Result;
KResourceLimit ResourceLimit = new KResourceLimit(System);
long ApplicationRgSize = (long)System.MemoryRegions[(int)MemoryRegion.Application].Size;
Result = ResourceLimit.SetLimitValue(LimitableResource.Memory, ApplicationRgSize);
Result |= ResourceLimit.SetLimitValue(LimitableResource.Thread, 608);
Result |= ResourceLimit.SetLimitValue(LimitableResource.Event, 700);
Result |= ResourceLimit.SetLimitValue(LimitableResource.TransferMemory, 128);
Result |= ResourceLimit.SetLimitValue(LimitableResource.Session, 894);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization failed setting resource limit values.");
return(false);
}
KProcess Process = new KProcess(System);
Result = Process.Initialize(
CreationInfo,
MetaData.ACI0.KernelAccessControl.Capabilities,
ResourceLimit,
MemoryRegion.Application);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
return(false);
}
for (int Index = 0; Index < StaticObjects.Length; Index++)
{
Logger.PrintInfo(LogClass.Loader, $"Loading image {Index} at 0x{NsoBase[Index]:x16}...");
Result = LoadIntoMemory(Process, StaticObjects[Index], NsoBase[Index]);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process initialization returned error \"{Result}\".");
return(false);
}
}
Result = Process.Start(MetaData.MainThreadPriority, (ulong)MetaData.MainThreadStackSize);
if (Result != KernelResult.Success)
{
Logger.PrintError(LogClass.Loader, $"Process start returned error \"{Result}\".");
return(false);
}
System.Processes.Add(Process.Pid, Process);
return(true);
}