1013 lines
No EOL
30 KiB
C#
1013 lines
No EOL
30 KiB
C#
using ChocolArm64;
|
|
using ChocolArm64.Events;
|
|
using ChocolArm64.Memory;
|
|
using Ryujinx.Common;
|
|
using Ryujinx.Common.Logging;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
|
|
namespace Ryujinx.HLE.HOS.Kernel
|
|
{
|
|
class KProcess : KSynchronizationObject
|
|
{
|
|
public const int KernelVersionMajor = 10;
|
|
public const int KernelVersionMinor = 4;
|
|
public const int KernelVersionRevision = 0;
|
|
|
|
public const int KernelVersionPacked =
|
|
(KernelVersionMajor << 19) |
|
|
(KernelVersionMinor << 15) |
|
|
(KernelVersionRevision << 0);
|
|
|
|
public KMemoryManager MemoryManager { get; private set; }
|
|
|
|
private SortedDictionary<ulong, KTlsPageInfo> FullTlsPages;
|
|
private SortedDictionary<ulong, KTlsPageInfo> FreeTlsPages;
|
|
|
|
public int DefaultCpuCore { get; private set; }
|
|
|
|
public bool Debug { get; private set; }
|
|
|
|
public KResourceLimit ResourceLimit { get; private set; }
|
|
|
|
public ulong PersonalMmHeapPagesCount { get; private set; }
|
|
|
|
private ProcessState State;
|
|
|
|
private object ProcessLock;
|
|
private object ThreadingLock;
|
|
|
|
public KAddressArbiter AddressArbiter { get; private set; }
|
|
|
|
public long[] RandomEntropy { get; private set; }
|
|
|
|
private bool Signaled;
|
|
private bool UseSystemMemBlocks;
|
|
|
|
public string Name { get; private set; }
|
|
|
|
private int ThreadCount;
|
|
|
|
public int MmuFlags { get; private set; }
|
|
|
|
private MemoryRegion MemRegion;
|
|
|
|
public KProcessCapabilities Capabilities { get; private set; }
|
|
|
|
public long TitleId { get; private set; }
|
|
public long Pid { get; private set; }
|
|
|
|
private long CreationTimestamp;
|
|
private ulong Entrypoint;
|
|
private ulong ImageSize;
|
|
private ulong MainThreadStackSize;
|
|
private ulong MemoryUsageCapacity;
|
|
private int Category;
|
|
|
|
public KHandleTable HandleTable { get; private set; }
|
|
|
|
public ulong UserExceptionContextAddress { get; private set; }
|
|
|
|
private LinkedList<KThread> Threads;
|
|
|
|
public bool IsPaused { get; private set; }
|
|
|
|
public Translator Translator { get; private set; }
|
|
|
|
public MemoryManager CpuMemory { get; private set; }
|
|
|
|
private SvcHandler SvcHandler;
|
|
|
|
public HleProcessDebugger Debugger { get; private set; }
|
|
|
|
public KProcess(Horizon System) : base(System)
|
|
{
|
|
ProcessLock = new object();
|
|
ThreadingLock = new object();
|
|
|
|
CpuMemory = new MemoryManager(System.Device.Memory.RamPointer);
|
|
|
|
CpuMemory.InvalidAccess += InvalidAccessHandler;
|
|
|
|
AddressArbiter = new KAddressArbiter(System);
|
|
|
|
MemoryManager = new KMemoryManager(System, CpuMemory);
|
|
|
|
FullTlsPages = new SortedDictionary<ulong, KTlsPageInfo>();
|
|
FreeTlsPages = new SortedDictionary<ulong, KTlsPageInfo>();
|
|
|
|
Capabilities = new KProcessCapabilities();
|
|
|
|
RandomEntropy = new long[KScheduler.CpuCoresCount];
|
|
|
|
Threads = new LinkedList<KThread>();
|
|
|
|
Translator = new Translator();
|
|
|
|
Translator.CpuTrace += CpuTraceHandler;
|
|
|
|
SvcHandler = new SvcHandler(System.Device, this);
|
|
|
|
Debugger = new HleProcessDebugger(this);
|
|
}
|
|
|
|
public KernelResult InitializeKip(
|
|
ProcessCreationInfo CreationInfo,
|
|
int[] Caps,
|
|
KPageList PageList,
|
|
KResourceLimit ResourceLimit,
|
|
MemoryRegion MemRegion)
|
|
{
|
|
this.ResourceLimit = ResourceLimit;
|
|
this.MemRegion = MemRegion;
|
|
|
|
AddressSpaceType AddrSpaceType = (AddressSpaceType)((CreationInfo.MmuFlags >> 1) & 7);
|
|
|
|
bool AslrEnabled = ((CreationInfo.MmuFlags >> 5) & 1) != 0;
|
|
|
|
ulong CodeAddress = CreationInfo.CodeAddress;
|
|
|
|
ulong CodeSize = (ulong)CreationInfo.CodePagesCount * KMemoryManager.PageSize;
|
|
|
|
KMemoryBlockAllocator MemoryBlockAllocator = (MmuFlags & 0x40) != 0
|
|
? System.LargeMemoryBlockAllocator
|
|
: System.SmallMemoryBlockAllocator;
|
|
|
|
KernelResult Result = MemoryManager.InitializeForProcess(
|
|
AddrSpaceType,
|
|
AslrEnabled,
|
|
!AslrEnabled,
|
|
MemRegion,
|
|
CodeAddress,
|
|
CodeSize,
|
|
MemoryBlockAllocator);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
return Result;
|
|
}
|
|
|
|
if (!ValidateCodeAddressAndSize(CodeAddress, CodeSize))
|
|
{
|
|
return KernelResult.InvalidMemRange;
|
|
}
|
|
|
|
Result = MemoryManager.MapPages(
|
|
CodeAddress,
|
|
PageList,
|
|
MemoryState.CodeStatic,
|
|
MemoryPermission.None);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
return Result;
|
|
}
|
|
|
|
Result = Capabilities.InitializeForKernel(Caps, MemoryManager);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
return Result;
|
|
}
|
|
|
|
Pid = System.GetKipId();
|
|
|
|
if (Pid == 0 || (ulong)Pid >= Horizon.InitialProcessId)
|
|
{
|
|
throw new InvalidOperationException($"Invalid KIP Id {Pid}.");
|
|
}
|
|
|
|
Result = ParseProcessInfo(CreationInfo);
|
|
|
|
return Result;
|
|
}
|
|
|
|
public KernelResult Initialize(
|
|
ProcessCreationInfo CreationInfo,
|
|
int[] Caps,
|
|
KResourceLimit ResourceLimit,
|
|
MemoryRegion MemRegion)
|
|
{
|
|
this.ResourceLimit = ResourceLimit;
|
|
this.MemRegion = MemRegion;
|
|
|
|
ulong PersonalMmHeapSize = GetPersonalMmHeapSize((ulong)CreationInfo.PersonalMmHeapPagesCount, MemRegion);
|
|
|
|
ulong CodePagesCount = (ulong)CreationInfo.CodePagesCount;
|
|
|
|
ulong NeededSizeForProcess = PersonalMmHeapSize + CodePagesCount * KMemoryManager.PageSize;
|
|
|
|
if (NeededSizeForProcess != 0 && ResourceLimit != null)
|
|
{
|
|
if (!ResourceLimit.Reserve(LimitableResource.Memory, NeededSizeForProcess))
|
|
{
|
|
return KernelResult.ResLimitExceeded;
|
|
}
|
|
}
|
|
|
|
void CleanUpForError()
|
|
{
|
|
if (NeededSizeForProcess != 0 && ResourceLimit != null)
|
|
{
|
|
ResourceLimit.Release(LimitableResource.Memory, NeededSizeForProcess);
|
|
}
|
|
}
|
|
|
|
PersonalMmHeapPagesCount = (ulong)CreationInfo.PersonalMmHeapPagesCount;
|
|
|
|
KMemoryBlockAllocator MemoryBlockAllocator;
|
|
|
|
if (PersonalMmHeapPagesCount != 0)
|
|
{
|
|
MemoryBlockAllocator = new KMemoryBlockAllocator(PersonalMmHeapPagesCount * KMemoryManager.PageSize);
|
|
}
|
|
else
|
|
{
|
|
MemoryBlockAllocator = (MmuFlags & 0x40) != 0
|
|
? System.LargeMemoryBlockAllocator
|
|
: System.SmallMemoryBlockAllocator;
|
|
}
|
|
|
|
AddressSpaceType AddrSpaceType = (AddressSpaceType)((CreationInfo.MmuFlags >> 1) & 7);
|
|
|
|
bool AslrEnabled = ((CreationInfo.MmuFlags >> 5) & 1) != 0;
|
|
|
|
ulong CodeAddress = CreationInfo.CodeAddress;
|
|
|
|
ulong CodeSize = CodePagesCount * KMemoryManager.PageSize;
|
|
|
|
KernelResult Result = MemoryManager.InitializeForProcess(
|
|
AddrSpaceType,
|
|
AslrEnabled,
|
|
!AslrEnabled,
|
|
MemRegion,
|
|
CodeAddress,
|
|
CodeSize,
|
|
MemoryBlockAllocator);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
if (!ValidateCodeAddressAndSize(CodeAddress, CodeSize))
|
|
{
|
|
CleanUpForError();
|
|
|
|
return KernelResult.InvalidMemRange;
|
|
}
|
|
|
|
Result = MemoryManager.MapNewProcessCode(
|
|
CodeAddress,
|
|
CodePagesCount,
|
|
MemoryState.CodeStatic,
|
|
MemoryPermission.None);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
Result = Capabilities.InitializeForUser(Caps, MemoryManager);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
Pid = System.GetProcessId();
|
|
|
|
if (Pid == -1 || (ulong)Pid < Horizon.InitialProcessId)
|
|
{
|
|
throw new InvalidOperationException($"Invalid Process Id {Pid}.");
|
|
}
|
|
|
|
Result = ParseProcessInfo(CreationInfo);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
private bool ValidateCodeAddressAndSize(ulong Address, ulong Size)
|
|
{
|
|
ulong CodeRegionStart;
|
|
ulong CodeRegionSize;
|
|
|
|
switch (MemoryManager.AddrSpaceWidth)
|
|
{
|
|
case 32:
|
|
CodeRegionStart = 0x200000;
|
|
CodeRegionSize = 0x3fe00000;
|
|
break;
|
|
|
|
case 36:
|
|
CodeRegionStart = 0x8000000;
|
|
CodeRegionSize = 0x78000000;
|
|
break;
|
|
|
|
case 39:
|
|
CodeRegionStart = 0x8000000;
|
|
CodeRegionSize = 0x7ff8000000;
|
|
break;
|
|
|
|
default: throw new InvalidOperationException("Invalid address space width on memory manager.");
|
|
}
|
|
|
|
ulong EndAddr = Address + Size;
|
|
|
|
ulong CodeRegionEnd = CodeRegionStart + CodeRegionSize;
|
|
|
|
if (EndAddr <= Address ||
|
|
EndAddr - 1 > CodeRegionEnd - 1)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (MemoryManager.InsideHeapRegion (Address, Size) ||
|
|
MemoryManager.InsideAliasRegion(Address, Size))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private KernelResult ParseProcessInfo(ProcessCreationInfo CreationInfo)
|
|
{
|
|
//Ensure that the current kernel version is equal or above to the minimum required.
|
|
uint RequiredKernelVersionMajor = (uint)Capabilities.KernelReleaseVersion >> 19;
|
|
uint RequiredKernelVersionMinor = ((uint)Capabilities.KernelReleaseVersion >> 15) & 0xf;
|
|
|
|
if (System.EnableVersionChecks)
|
|
{
|
|
if (RequiredKernelVersionMajor > KernelVersionMajor)
|
|
{
|
|
return KernelResult.InvalidCombination;
|
|
}
|
|
|
|
if (RequiredKernelVersionMajor != KernelVersionMajor && RequiredKernelVersionMajor < 3)
|
|
{
|
|
return KernelResult.InvalidCombination;
|
|
}
|
|
|
|
if (RequiredKernelVersionMinor > KernelVersionMinor)
|
|
{
|
|
return KernelResult.InvalidCombination;
|
|
}
|
|
}
|
|
|
|
KernelResult Result = AllocateThreadLocalStorage(out ulong UserExceptionContextAddress);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
return Result;
|
|
}
|
|
|
|
this.UserExceptionContextAddress = UserExceptionContextAddress;
|
|
|
|
MemoryHelper.FillWithZeros(CpuMemory, (long)UserExceptionContextAddress, KTlsPageInfo.TlsEntrySize);
|
|
|
|
Name = CreationInfo.Name;
|
|
|
|
State = ProcessState.Created;
|
|
|
|
CreationTimestamp = PerformanceCounter.ElapsedMilliseconds;
|
|
|
|
MmuFlags = CreationInfo.MmuFlags;
|
|
Category = CreationInfo.Category;
|
|
TitleId = CreationInfo.TitleId;
|
|
Entrypoint = CreationInfo.CodeAddress;
|
|
ImageSize = (ulong)CreationInfo.CodePagesCount * KMemoryManager.PageSize;
|
|
|
|
UseSystemMemBlocks = ((MmuFlags >> 6) & 1) != 0;
|
|
|
|
switch ((AddressSpaceType)((MmuFlags >> 1) & 7))
|
|
{
|
|
case AddressSpaceType.Addr32Bits:
|
|
case AddressSpaceType.Addr36Bits:
|
|
case AddressSpaceType.Addr39Bits:
|
|
MemoryUsageCapacity = MemoryManager.HeapRegionEnd -
|
|
MemoryManager.HeapRegionStart;
|
|
break;
|
|
|
|
case AddressSpaceType.Addr32BitsNoMap:
|
|
MemoryUsageCapacity = MemoryManager.HeapRegionEnd -
|
|
MemoryManager.HeapRegionStart +
|
|
MemoryManager.AliasRegionEnd -
|
|
MemoryManager.AliasRegionStart;
|
|
break;
|
|
|
|
default: throw new InvalidOperationException($"Invalid MMU flags value 0x{MmuFlags:x2}.");
|
|
}
|
|
|
|
GenerateRandomEntropy();
|
|
|
|
return KernelResult.Success;
|
|
}
|
|
|
|
public KernelResult AllocateThreadLocalStorage(out ulong Address)
|
|
{
|
|
System.CriticalSection.Enter();
|
|
|
|
KernelResult Result;
|
|
|
|
if (FreeTlsPages.Count > 0)
|
|
{
|
|
//If we have free TLS pages available, just use the first one.
|
|
KTlsPageInfo PageInfo = FreeTlsPages.Values.First();
|
|
|
|
if (!PageInfo.TryGetFreePage(out Address))
|
|
{
|
|
throw new InvalidOperationException("Unexpected failure getting free TLS page!");
|
|
}
|
|
|
|
if (PageInfo.IsFull())
|
|
{
|
|
FreeTlsPages.Remove(PageInfo.PageAddr);
|
|
|
|
FullTlsPages.Add(PageInfo.PageAddr, PageInfo);
|
|
}
|
|
|
|
Result = KernelResult.Success;
|
|
}
|
|
else
|
|
{
|
|
//Otherwise, we need to create a new one.
|
|
Result = AllocateTlsPage(out KTlsPageInfo PageInfo);
|
|
|
|
if (Result == KernelResult.Success)
|
|
{
|
|
if (!PageInfo.TryGetFreePage(out Address))
|
|
{
|
|
throw new InvalidOperationException("Unexpected failure getting free TLS page!");
|
|
}
|
|
|
|
FreeTlsPages.Add(PageInfo.PageAddr, PageInfo);
|
|
}
|
|
else
|
|
{
|
|
Address = 0;
|
|
}
|
|
}
|
|
|
|
System.CriticalSection.Leave();
|
|
|
|
return Result;
|
|
}
|
|
|
|
private KernelResult AllocateTlsPage(out KTlsPageInfo PageInfo)
|
|
{
|
|
PageInfo = default(KTlsPageInfo);
|
|
|
|
if (!System.UserSlabHeapPages.TryGetItem(out ulong TlsPagePa))
|
|
{
|
|
return KernelResult.OutOfMemory;
|
|
}
|
|
|
|
ulong RegionStart = MemoryManager.TlsIoRegionStart;
|
|
ulong RegionSize = MemoryManager.TlsIoRegionEnd - RegionStart;
|
|
|
|
ulong RegionPagesCount = RegionSize / KMemoryManager.PageSize;
|
|
|
|
KernelResult Result = MemoryManager.AllocateOrMapPa(
|
|
1,
|
|
KMemoryManager.PageSize,
|
|
TlsPagePa,
|
|
true,
|
|
RegionStart,
|
|
RegionPagesCount,
|
|
MemoryState.ThreadLocal,
|
|
MemoryPermission.ReadAndWrite,
|
|
out ulong TlsPageVa);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
System.UserSlabHeapPages.Free(TlsPagePa);
|
|
}
|
|
else
|
|
{
|
|
PageInfo = new KTlsPageInfo(TlsPageVa);
|
|
|
|
MemoryHelper.FillWithZeros(CpuMemory, (long)TlsPageVa, KMemoryManager.PageSize);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
public KernelResult FreeThreadLocalStorage(ulong TlsSlotAddr)
|
|
{
|
|
ulong TlsPageAddr = BitUtils.AlignDown(TlsSlotAddr, KMemoryManager.PageSize);
|
|
|
|
System.CriticalSection.Enter();
|
|
|
|
KernelResult Result = KernelResult.Success;
|
|
|
|
KTlsPageInfo PageInfo = null;
|
|
|
|
if (FullTlsPages.TryGetValue(TlsPageAddr, out PageInfo))
|
|
{
|
|
//TLS page was full, free slot and move to free pages tree.
|
|
FullTlsPages.Remove(TlsPageAddr);
|
|
|
|
FreeTlsPages.Add(TlsPageAddr, PageInfo);
|
|
}
|
|
else if (!FreeTlsPages.TryGetValue(TlsPageAddr, out PageInfo))
|
|
{
|
|
Result = KernelResult.InvalidAddress;
|
|
}
|
|
|
|
if (PageInfo != null)
|
|
{
|
|
PageInfo.FreeTlsSlot(TlsSlotAddr);
|
|
|
|
if (PageInfo.IsEmpty())
|
|
{
|
|
//TLS page is now empty, we should ensure it is removed
|
|
//from all trees, and free the memory it was using.
|
|
FreeTlsPages.Remove(TlsPageAddr);
|
|
|
|
System.CriticalSection.Leave();
|
|
|
|
FreeTlsPage(PageInfo);
|
|
|
|
return KernelResult.Success;
|
|
}
|
|
}
|
|
|
|
System.CriticalSection.Leave();
|
|
|
|
return Result;
|
|
}
|
|
|
|
private KernelResult FreeTlsPage(KTlsPageInfo PageInfo)
|
|
{
|
|
KernelResult Result = MemoryManager.ConvertVaToPa(PageInfo.PageAddr, out ulong TlsPagePa);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
throw new InvalidOperationException("Unexpected failure translating virtual address to physical.");
|
|
}
|
|
|
|
Result = MemoryManager.UnmapForKernel(PageInfo.PageAddr, 1, MemoryState.ThreadLocal);
|
|
|
|
if (Result == KernelResult.Success)
|
|
{
|
|
System.UserSlabHeapPages.Free(TlsPagePa);
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
private void GenerateRandomEntropy()
|
|
{
|
|
//TODO.
|
|
}
|
|
|
|
public KernelResult Start(int MainThreadPriority, ulong StackSize)
|
|
{
|
|
lock (ProcessLock)
|
|
{
|
|
if (State > ProcessState.CreatedAttached)
|
|
{
|
|
return KernelResult.InvalidState;
|
|
}
|
|
|
|
if (ResourceLimit != null && !ResourceLimit.Reserve(LimitableResource.Thread, 1))
|
|
{
|
|
return KernelResult.ResLimitExceeded;
|
|
}
|
|
|
|
KResourceLimit ThreadResourceLimit = ResourceLimit;
|
|
KResourceLimit MemoryResourceLimit = null;
|
|
|
|
if (MainThreadStackSize != 0)
|
|
{
|
|
throw new InvalidOperationException("Trying to start a process with a invalid state!");
|
|
}
|
|
|
|
ulong StackSizeRounded = BitUtils.AlignUp(StackSize, KMemoryManager.PageSize);
|
|
|
|
ulong NeededSize = StackSizeRounded + ImageSize;
|
|
|
|
//Check if the needed size for the code and the stack will fit on the
|
|
//memory usage capacity of this Process. Also check for possible overflow
|
|
//on the above addition.
|
|
if (NeededSize > MemoryUsageCapacity ||
|
|
NeededSize < StackSizeRounded)
|
|
{
|
|
ThreadResourceLimit?.Release(LimitableResource.Thread, 1);
|
|
|
|
return KernelResult.OutOfMemory;
|
|
}
|
|
|
|
if (StackSizeRounded != 0 && ResourceLimit != null)
|
|
{
|
|
MemoryResourceLimit = ResourceLimit;
|
|
|
|
if (!MemoryResourceLimit.Reserve(LimitableResource.Memory, StackSizeRounded))
|
|
{
|
|
ThreadResourceLimit?.Release(LimitableResource.Thread, 1);
|
|
|
|
return KernelResult.ResLimitExceeded;
|
|
}
|
|
}
|
|
|
|
KernelResult Result;
|
|
|
|
KThread MainThread = null;
|
|
|
|
ulong StackTop = 0;
|
|
|
|
void CleanUpForError()
|
|
{
|
|
MainThread?.Terminate();
|
|
HandleTable.Destroy();
|
|
|
|
if (MainThreadStackSize != 0)
|
|
{
|
|
ulong StackBottom = StackTop - MainThreadStackSize;
|
|
|
|
ulong StackPagesCount = MainThreadStackSize / KMemoryManager.PageSize;
|
|
|
|
MemoryManager.UnmapForKernel(StackBottom, StackPagesCount, MemoryState.Stack);
|
|
}
|
|
|
|
MemoryResourceLimit?.Release(LimitableResource.Memory, StackSizeRounded);
|
|
ThreadResourceLimit?.Release(LimitableResource.Thread, 1);
|
|
}
|
|
|
|
if (StackSizeRounded != 0)
|
|
{
|
|
ulong StackPagesCount = StackSizeRounded / KMemoryManager.PageSize;
|
|
|
|
ulong RegionStart = MemoryManager.StackRegionStart;
|
|
ulong RegionSize = MemoryManager.StackRegionEnd - RegionStart;
|
|
|
|
ulong RegionPagesCount = RegionSize / KMemoryManager.PageSize;
|
|
|
|
Result = MemoryManager.AllocateOrMapPa(
|
|
StackPagesCount,
|
|
KMemoryManager.PageSize,
|
|
0,
|
|
false,
|
|
RegionStart,
|
|
RegionPagesCount,
|
|
MemoryState.Stack,
|
|
MemoryPermission.ReadAndWrite,
|
|
out ulong StackBottom);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
MainThreadStackSize += StackSizeRounded;
|
|
|
|
StackTop = StackBottom + StackSizeRounded;
|
|
}
|
|
|
|
ulong HeapCapacity = MemoryUsageCapacity - MainThreadStackSize - ImageSize;
|
|
|
|
Result = MemoryManager.SetHeapCapacity(HeapCapacity);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
HandleTable = new KHandleTable(System);
|
|
|
|
Result = HandleTable.Initialize(Capabilities.HandleTableSize);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
MainThread = new KThread(System);
|
|
|
|
Result = MainThread.Initialize(
|
|
Entrypoint,
|
|
0,
|
|
StackTop,
|
|
MainThreadPriority,
|
|
DefaultCpuCore,
|
|
this);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
Result = HandleTable.GenerateHandle(MainThread, out int MainThreadHandle);
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
CleanUpForError();
|
|
|
|
return Result;
|
|
}
|
|
|
|
MainThread.SetEntryArguments(0, MainThreadHandle);
|
|
|
|
ProcessState OldState = State;
|
|
ProcessState NewState = State != ProcessState.Created
|
|
? ProcessState.Attached
|
|
: ProcessState.Started;
|
|
|
|
SetState(NewState);
|
|
|
|
//TODO: We can't call KThread.Start from a non-guest thread.
|
|
//We will need to make some changes to allow the creation of
|
|
//dummy threads that will be used to initialize the current
|
|
//thread on KCoreContext so that GetCurrentThread doesn't fail.
|
|
/* Result = MainThread.Start();
|
|
|
|
if (Result != KernelResult.Success)
|
|
{
|
|
SetState(OldState);
|
|
|
|
CleanUpForError();
|
|
} */
|
|
|
|
MainThread.Reschedule(ThreadSchedState.Running);
|
|
|
|
return Result;
|
|
}
|
|
}
|
|
|
|
private void SetState(ProcessState NewState)
|
|
{
|
|
if (State != NewState)
|
|
{
|
|
State = NewState;
|
|
Signaled = true;
|
|
|
|
Signal();
|
|
}
|
|
}
|
|
|
|
public KernelResult InitializeThread(
|
|
KThread Thread,
|
|
ulong Entrypoint,
|
|
ulong ArgsPtr,
|
|
ulong StackTop,
|
|
int Priority,
|
|
int CpuCore)
|
|
{
|
|
lock (ProcessLock)
|
|
{
|
|
return Thread.Initialize(Entrypoint, ArgsPtr, StackTop, Priority, CpuCore, this);
|
|
}
|
|
}
|
|
|
|
public void SubscribeThreadEventHandlers(CpuThread Context)
|
|
{
|
|
Context.ThreadState.Interrupt += InterruptHandler;
|
|
Context.ThreadState.SvcCall += SvcHandler.SvcCall;
|
|
}
|
|
|
|
private void InterruptHandler(object sender, EventArgs e)
|
|
{
|
|
System.Scheduler.ContextSwitch();
|
|
}
|
|
|
|
public void IncrementThreadCount()
|
|
{
|
|
Interlocked.Increment(ref ThreadCount);
|
|
|
|
System.ThreadCounter.AddCount();
|
|
}
|
|
|
|
public void DecrementThreadCountAndTerminateIfZero()
|
|
{
|
|
System.ThreadCounter.Signal();
|
|
|
|
if (Interlocked.Decrement(ref ThreadCount) == 0)
|
|
{
|
|
Terminate();
|
|
}
|
|
}
|
|
|
|
public ulong GetMemoryCapacity()
|
|
{
|
|
ulong TotalCapacity = (ulong)ResourceLimit.GetRemainingValue(LimitableResource.Memory);
|
|
|
|
TotalCapacity += MemoryManager.GetTotalHeapSize();
|
|
|
|
TotalCapacity += GetPersonalMmHeapSize();
|
|
|
|
TotalCapacity += ImageSize + MainThreadStackSize;
|
|
|
|
if (TotalCapacity <= MemoryUsageCapacity)
|
|
{
|
|
return TotalCapacity;
|
|
}
|
|
|
|
return MemoryUsageCapacity;
|
|
}
|
|
|
|
public ulong GetMemoryUsage()
|
|
{
|
|
return ImageSize + MainThreadStackSize + MemoryManager.GetTotalHeapSize() + GetPersonalMmHeapSize();
|
|
}
|
|
|
|
public ulong GetMemoryCapacityWithoutPersonalMmHeap()
|
|
{
|
|
return GetMemoryCapacity() - GetPersonalMmHeapSize();
|
|
}
|
|
|
|
public ulong GetMemoryUsageWithoutPersonalMmHeap()
|
|
{
|
|
return GetMemoryUsage() - GetPersonalMmHeapSize();
|
|
}
|
|
|
|
private ulong GetPersonalMmHeapSize()
|
|
{
|
|
return GetPersonalMmHeapSize(PersonalMmHeapPagesCount, MemRegion);
|
|
}
|
|
|
|
private static ulong GetPersonalMmHeapSize(ulong PersonalMmHeapPagesCount, MemoryRegion MemRegion)
|
|
{
|
|
if (MemRegion == MemoryRegion.Applet)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return PersonalMmHeapPagesCount * KMemoryManager.PageSize;
|
|
}
|
|
|
|
public void AddThread(KThread Thread)
|
|
{
|
|
lock (ThreadingLock)
|
|
{
|
|
Thread.ProcessListNode = Threads.AddLast(Thread);
|
|
}
|
|
}
|
|
|
|
public void RemoveThread(KThread Thread)
|
|
{
|
|
lock (ThreadingLock)
|
|
{
|
|
Threads.Remove(Thread.ProcessListNode);
|
|
}
|
|
}
|
|
|
|
public bool IsCpuCoreAllowed(int Core)
|
|
{
|
|
return (Capabilities.AllowedCpuCoresMask & (1L << Core)) != 0;
|
|
}
|
|
|
|
public bool IsPriorityAllowed(int Priority)
|
|
{
|
|
return (Capabilities.AllowedThreadPriosMask & (1L << Priority)) != 0;
|
|
}
|
|
|
|
public override bool IsSignaled()
|
|
{
|
|
return Signaled;
|
|
}
|
|
|
|
public KernelResult Terminate()
|
|
{
|
|
KernelResult Result;
|
|
|
|
bool ShallTerminate = false;
|
|
|
|
System.CriticalSection.Enter();
|
|
|
|
lock (ProcessLock)
|
|
{
|
|
if (State >= ProcessState.Started)
|
|
{
|
|
if (State == ProcessState.Started ||
|
|
State == ProcessState.Crashed ||
|
|
State == ProcessState.Attached ||
|
|
State == ProcessState.DebugSuspended)
|
|
{
|
|
SetState(ProcessState.Exiting);
|
|
|
|
ShallTerminate = true;
|
|
}
|
|
|
|
Result = KernelResult.Success;
|
|
}
|
|
else
|
|
{
|
|
Result = KernelResult.InvalidState;
|
|
}
|
|
}
|
|
|
|
System.CriticalSection.Leave();
|
|
|
|
if (ShallTerminate)
|
|
{
|
|
//UnpauseAndTerminateAllThreadsExcept(System.Scheduler.GetCurrentThread());
|
|
|
|
HandleTable.Destroy();
|
|
|
|
SignalExitForDebugEvent();
|
|
SignalExit();
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
private void UnpauseAndTerminateAllThreadsExcept(KThread Thread)
|
|
{
|
|
//TODO.
|
|
}
|
|
|
|
private void SignalExitForDebugEvent()
|
|
{
|
|
//TODO: Debug events.
|
|
}
|
|
|
|
private void SignalExit()
|
|
{
|
|
if (ResourceLimit != null)
|
|
{
|
|
ResourceLimit.Release(LimitableResource.Memory, GetMemoryUsage());
|
|
}
|
|
|
|
System.CriticalSection.Enter();
|
|
|
|
SetState(ProcessState.Exited);
|
|
|
|
System.CriticalSection.Leave();
|
|
}
|
|
|
|
public KernelResult ClearIfNotExited()
|
|
{
|
|
KernelResult Result;
|
|
|
|
System.CriticalSection.Enter();
|
|
|
|
lock (ProcessLock)
|
|
{
|
|
if (State != ProcessState.Exited && Signaled)
|
|
{
|
|
Signaled = false;
|
|
|
|
Result = KernelResult.Success;
|
|
}
|
|
else
|
|
{
|
|
Result = KernelResult.InvalidState;
|
|
}
|
|
}
|
|
|
|
System.CriticalSection.Leave();
|
|
|
|
return Result;
|
|
}
|
|
|
|
public void StopAllThreads()
|
|
{
|
|
lock (ThreadingLock)
|
|
{
|
|
foreach (KThread Thread in Threads)
|
|
{
|
|
Thread.Context.StopExecution();
|
|
|
|
System.Scheduler.CoreManager.Set(Thread.Context.Work);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void InvalidAccessHandler(object sender, InvalidAccessEventArgs e)
|
|
{
|
|
PrintCurrentThreadStackTrace();
|
|
}
|
|
|
|
public void PrintCurrentThreadStackTrace()
|
|
{
|
|
System.Scheduler.GetCurrentThread().PrintGuestStackTrace();
|
|
}
|
|
|
|
private void CpuTraceHandler(object sender, CpuTraceEventArgs e)
|
|
{
|
|
Logger.PrintInfo(LogClass.Cpu, $"Executing at 0x{e.Position:X16}.");
|
|
}
|
|
}
|
|
} |