public static void InitializeResourceLimit(KResourceLimit ResourceLimit)
{
void EnsureSuccess(KernelResult Result)
{
if (Result != KernelResult.Success)
{
throw new InvalidOperationException($"Unexpected result \"{Result}\".");
}
}
int KernelMemoryCfg = 0;
long RamSize = GetRamSize(KernelMemoryCfg);
EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Memory, RamSize));
EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Thread, 800));
EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Event, 700));
EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.TransferMemory, 200));
EnsureSuccess(ResourceLimit.SetLimitValue(LimitableResource.Session, 900));
if (!ResourceLimit.Reserve(LimitableResource.Memory, 0) ||
!ResourceLimit.Reserve(LimitableResource.Memory, 0x60000))
{
throw new InvalidOperationException("Unexpected failure reserving memory on resource limit.");
}
}
public KernelContext(
ITickSource tickSource,
Switch device,
MemoryBlock memory,
MemorySize memorySize,
MemoryArrange memoryArrange)
{
TickSource = tickSource;
Device = device;
Memory = memory;
Running = true;
Syscall = new Syscall(this);
SyscallHandler = new SyscallHandler(this);
ResourceLimit = new KResourceLimit(this);
KernelInit.InitializeResourceLimit(ResourceLimit, memorySize);
MemoryManager = new KMemoryManager(memorySize, memoryArrange);
LargeMemoryBlockSlabManager = new KMemoryBlockSlabManager(KernelConstants.MemoryBlockAllocatorSize * 2);
SmallMemoryBlockSlabManager = new KMemoryBlockSlabManager(KernelConstants.MemoryBlockAllocatorSize);
UserSlabHeapPages = new KSlabHeap(
KernelConstants.UserSlabHeapBase,
KernelConstants.UserSlabHeapItemSize,
KernelConstants.UserSlabHeapSize);
memory.Commit(KernelConstants.UserSlabHeapBase - DramMemoryMap.DramBase, KernelConstants.UserSlabHeapSize);
CriticalSection = new KCriticalSection(this);
Schedulers = new KScheduler[KScheduler.CpuCoresCount];
PriorityQueue = new KPriorityQueue();
TimeManager = new KTimeManager(this);
Synchronization = new KSynchronization(this);
ContextIdManager = new KContextIdManager();
for (int core = 0; core < KScheduler.CpuCoresCount; core++)
{
Schedulers[core] = new KScheduler(this, core);
}
StartPreemptionThread();
KernelInitialized = true;
Processes = new ConcurrentDictionary <ulong, KProcess>();
AutoObjectNames = new ConcurrentDictionary <string, KAutoObject>();
_kipId = KernelConstants.InitialKipId;
_processId = KernelConstants.InitialProcessId;
}
public KernelContext(Switch device, MemoryBlock memory)
{
Device = device;
Memory = memory;
Syscall = new Syscall(device, this);
SyscallHandler = new SyscallHandler(this);
ThreadCounter = new CountdownEvent(1);
ResourceLimit = new KResourceLimit(this);
KernelInit.InitializeResourceLimit(ResourceLimit);
MemoryRegions = KernelInit.GetMemoryRegions();
LargeMemoryBlockAllocator = new KMemoryBlockAllocator(KernelConstants.MemoryBlockAllocatorSize * 2);
SmallMemoryBlockAllocator = new KMemoryBlockAllocator(KernelConstants.MemoryBlockAllocatorSize);
UserSlabHeapPages = new KSlabHeap(
KernelConstants.UserSlabHeapBase,
KernelConstants.UserSlabHeapItemSize,
KernelConstants.UserSlabHeapSize);
CriticalSection = new KCriticalSection(this);
Scheduler = new KScheduler(this);
TimeManager = new KTimeManager();
Synchronization = new KSynchronization(this);
ContextIdManager = new KContextIdManager();
Scheduler.StartAutoPreemptionThread();
KernelInitialized = true;
Processes = new ConcurrentDictionary <long, KProcess>();
AutoObjectNames = new ConcurrentDictionary <string, KAutoObject>();
_kipId = KernelConstants.InitialKipId;
_processId = KernelConstants.InitialProcessId;
}
private KernelResult GetInfo(uint id, int handle, long subId, out long value)
{
value = 0;
switch (id)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 20:
case 21:
case 22:
{
if (subId != 0)
{
return(KernelResult.InvalidCombination);
}
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
KProcess process = currentProcess.HandleTable.GetKProcess(handle);
if (process == null)
{
return(KernelResult.InvalidHandle);
}
switch (id)
{
case 0: value = process.Capabilities.AllowedCpuCoresMask; break;
case 1: value = process.Capabilities.AllowedThreadPriosMask; break;
case 2: value = (long)process.MemoryManager.AliasRegionStart; break;
case 3: value = (long)(process.MemoryManager.AliasRegionEnd -
process.MemoryManager.AliasRegionStart); break;
case 4: value = (long)process.MemoryManager.HeapRegionStart; break;
case 5: value = (long)(process.MemoryManager.HeapRegionEnd -
process.MemoryManager.HeapRegionStart); break;
case 6: value = (long)process.GetMemoryCapacity(); break;
case 7: value = (long)process.GetMemoryUsage(); break;
case 12: value = (long)process.MemoryManager.GetAddrSpaceBaseAddr(); break;
case 13: value = (long)process.MemoryManager.GetAddrSpaceSize(); break;
case 14: value = (long)process.MemoryManager.StackRegionStart; break;
case 15: value = (long)(process.MemoryManager.StackRegionEnd -
process.MemoryManager.StackRegionStart); break;
case 16: value = (long)process.PersonalMmHeapPagesCount * KMemoryManager.PageSize; break;
case 17:
if (process.PersonalMmHeapPagesCount != 0)
{
value = process.MemoryManager.GetMmUsedPages() * KMemoryManager.PageSize;
}
break;
case 18: value = process.TitleId; break;
case 20: value = (long)process.UserExceptionContextAddress; break;
case 21: value = (long)process.GetMemoryCapacityWithoutPersonalMmHeap(); break;
case 22: value = (long)process.GetMemoryUsageWithoutPersonalMmHeap(); break;
}
break;
}
case 8:
{
if (handle != 0)
{
return(KernelResult.InvalidHandle);
}
if (subId != 0)
{
return(KernelResult.InvalidCombination);
}
value = _system.Scheduler.GetCurrentProcess().Debug ? 1 : 0;
break;
}
case 9:
{
if (handle != 0)
{
return(KernelResult.InvalidHandle);
}
if (subId != 0)
{
return(KernelResult.InvalidCombination);
}
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
if (currentProcess.ResourceLimit != null)
{
KHandleTable handleTable = currentProcess.HandleTable;
KResourceLimit resourceLimit = currentProcess.ResourceLimit;
KernelResult result = handleTable.GenerateHandle(resourceLimit, out int resLimHandle);
if (result != KernelResult.Success)
{
return(result);
}
value = (uint)resLimHandle;
}
break;
}
case 10:
{
if (handle != 0)
{
return(KernelResult.InvalidHandle);
}
int currentCore = _system.Scheduler.GetCurrentThread().CurrentCore;
if (subId != -1 && subId != currentCore)
{
return(KernelResult.InvalidCombination);
}
value = _system.Scheduler.CoreContexts[currentCore].TotalIdleTimeTicks;
break;
}
case 11:
{
if (handle != 0)
{
return(KernelResult.InvalidHandle);
}
if ((ulong)subId > 3)
{
return(KernelResult.InvalidCombination);
}
KProcess currentProcess = _system.Scheduler.GetCurrentProcess();
value = currentProcess.RandomEntropy[subId];
break;
}
case 0xf0000002u:
{
if (subId < -1 || subId > 3)
{
return(KernelResult.InvalidCombination);
}
KThread thread = _system.Scheduler.GetCurrentProcess().HandleTable.GetKThread(handle);
if (thread == null)
{
return(KernelResult.InvalidHandle);
}
KThread currentThread = _system.Scheduler.GetCurrentThread();
int currentCore = currentThread.CurrentCore;
if (subId != -1 && subId != currentCore)
{
return(KernelResult.Success);
}
KCoreContext coreContext = _system.Scheduler.CoreContexts[currentCore];
long timeDelta = PerformanceCounter.ElapsedMilliseconds - coreContext.LastContextSwitchTime;
if (subId != -1)
{
value = KTimeManager.ConvertMillisecondsToTicks(timeDelta);
}
else
{
long totalTimeRunning = thread.TotalTimeRunning;
if (thread == currentThread)
{
totalTimeRunning += timeDelta;
}
value = KTimeManager.ConvertMillisecondsToTicks(totalTimeRunning);
}
break;
}
default: return(KernelResult.InvalidEnumValue);
}
return(KernelResult.Success);
}
private KernelResult GetInfo(uint Id, int Handle, long SubId, out long Value)
{
Value = 0;
switch (Id)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 20:
case 21:
case 22:
{
if (SubId != 0)
{
return(KernelResult.InvalidCombination);
}
KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
KProcess Process = CurrentProcess.HandleTable.GetKProcess(Handle);
if (Process == null)
{
return(KernelResult.InvalidHandle);
}
switch (Id)
{
case 0: Value = Process.Capabilities.AllowedCpuCoresMask; break;
case 1: Value = Process.Capabilities.AllowedThreadPriosMask; break;
case 2: Value = (long)Process.MemoryManager.AliasRegionStart; break;
case 3: Value = (long)(Process.MemoryManager.AliasRegionEnd -
Process.MemoryManager.AliasRegionStart); break;
case 4: Value = (long)Process.MemoryManager.HeapRegionStart; break;
case 5: Value = (long)(Process.MemoryManager.HeapRegionEnd -
Process.MemoryManager.HeapRegionStart); break;
case 6: Value = (long)Process.GetMemoryCapacity(); break;
case 7: Value = (long)Process.GetMemoryUsage(); break;
case 12: Value = (long)Process.MemoryManager.GetAddrSpaceBaseAddr(); break;
case 13: Value = (long)Process.MemoryManager.GetAddrSpaceSize(); break;
case 14: Value = (long)Process.MemoryManager.StackRegionStart; break;
case 15: Value = (long)(Process.MemoryManager.StackRegionEnd -
Process.MemoryManager.StackRegionStart); break;
case 16: Value = (long)Process.PersonalMmHeapPagesCount * KMemoryManager.PageSize; break;
case 17:
if (Process.PersonalMmHeapPagesCount != 0)
{
Value = Process.MemoryManager.GetMmUsedPages() * KMemoryManager.PageSize;
}
break;
case 18: Value = Process.TitleId; break;
case 20: Value = (long)Process.UserExceptionContextAddress; break;
case 21: Value = (long)Process.GetMemoryCapacityWithoutPersonalMmHeap(); break;
case 22: Value = (long)Process.GetMemoryUsageWithoutPersonalMmHeap(); break;
}
break;
}
case 8:
{
if (Handle != 0)
{
return(KernelResult.InvalidHandle);
}
if (SubId != 0)
{
return(KernelResult.InvalidCombination);
}
Value = System.Scheduler.GetCurrentProcess().Debug ? 1 : 0;
break;
}
case 9:
{
if (Handle != 0)
{
return(KernelResult.InvalidHandle);
}
if (SubId != 0)
{
return(KernelResult.InvalidCombination);
}
KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
if (CurrentProcess.ResourceLimit != null)
{
KHandleTable HandleTable = CurrentProcess.HandleTable;
KResourceLimit ResourceLimit = CurrentProcess.ResourceLimit;
KernelResult Result = HandleTable.GenerateHandle(ResourceLimit, out int ResLimHandle);
if (Result != KernelResult.Success)
{
return(Result);
}
Value = (uint)ResLimHandle;
}
break;
}
case 10:
{
if (Handle != 0)
{
return(KernelResult.InvalidHandle);
}
int CurrentCore = System.Scheduler.GetCurrentThread().CurrentCore;
if (SubId != -1 && SubId != CurrentCore)
{
return(KernelResult.InvalidCombination);
}
Value = System.Scheduler.CoreContexts[CurrentCore].TotalIdleTimeTicks;
break;
}
case 11:
{
if (Handle != 0)
{
return(KernelResult.InvalidHandle);
}
if ((ulong)SubId > 3)
{
return(KernelResult.InvalidCombination);
}
KProcess CurrentProcess = System.Scheduler.GetCurrentProcess();
Value = CurrentProcess.RandomEntropy[SubId];
break;
}
case 0xf0000002u:
{
if (SubId < -1 || SubId > 3)
{
return(KernelResult.InvalidCombination);
}
KThread Thread = System.Scheduler.GetCurrentProcess().HandleTable.GetKThread(Handle);
if (Thread == null)
{
return(KernelResult.InvalidHandle);
}
KThread CurrentThread = System.Scheduler.GetCurrentThread();
int CurrentCore = CurrentThread.CurrentCore;
if (SubId != -1 && SubId != CurrentCore)
{
return(KernelResult.Success);
}
KCoreContext CoreContext = System.Scheduler.CoreContexts[CurrentCore];
long TimeDelta = PerformanceCounter.ElapsedMilliseconds - CoreContext.LastContextSwitchTime;
if (SubId != -1)
{
Value = KTimeManager.ConvertMillisecondsToTicks(TimeDelta);
}
else
{
long TotalTimeRunning = Thread.TotalTimeRunning;
if (Thread == CurrentThread)
{
TotalTimeRunning += TimeDelta;
}
Value = KTimeManager.ConvertMillisecondsToTicks(TotalTimeRunning);
}
break;
}
default: return(KernelResult.InvalidEnumValue);
}
return(KernelResult.Success);
}
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);
}
}
public KernelResult Initialize(
ProcessCreationInfo creationInfo,
int[] caps,
KResourceLimit resourceLimit,
MemoryRegion memRegion)
{
ResourceLimit = resourceLimit;
_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);
}
public KernelResult InitializeKip(
ProcessCreationInfo creationInfo,
int[] caps,
KPageList pageList,
KResourceLimit resourceLimit,
MemoryRegion memRegion)
{
ResourceLimit = resourceLimit;
_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);
}
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);
}
