632 lines
22 KiB
C#
632 lines
22 KiB
C#
|
///////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// Microsoft Research Singularity
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//
|
||
|
|
// File: Kernel.cs
|
||
|
|
//
|
||
|
|
// Note:
|
||
|
|
//
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Collections;
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.Reflection;
|
||
|
|
using System.Runtime.CompilerServices;
|
||
|
|
using System.Runtime.InteropServices;
|
||
|
|
using System.Threading;
|
||
|
|
|
||
|
|
using Microsoft.Bartok.Runtime;
|
||
|
|
|
||
|
|
using Microsoft.SingSharp;
|
||
|
|
using Microsoft.Singularity.Channels;
|
||
|
|
using Microsoft.Singularity.Drivers;
|
||
|
|
using Microsoft.Singularity.Hal;
|
||
|
|
using Microsoft.Singularity.Io;
|
||
|
|
using Microsoft.Singularity.Loader;
|
||
|
|
using Microsoft.Singularity.Memory;
|
||
|
|
using Microsoft.Singularity.Scheduling;
|
||
|
|
|
||
|
|
using Microsoft.Singularity.Directory;
|
||
|
|
using Microsoft.Singularity.Security;
|
||
|
|
using Microsoft.Singularity.Xml;
|
||
|
|
using Microsoft.Singularity.V1.Services;
|
||
|
|
|
||
|
|
[assembly: AssemblyTitle("Microsoft.Singularity")]
|
||
|
|
[assembly: AssemblyProduct("Microsoft Research Singularity Operating System")]
|
||
|
|
[assembly: AssemblyCompany("Microsoft Corporation")]
|
||
|
|
[assembly: AssemblyVersion("1.0.0.0")]
|
||
|
|
[assembly: AssemblyKeyFile("public.snk")]
|
||
|
|
[assembly: AssemblyDelaySign(true)]
|
||
|
|
|
||
|
|
namespace Microsoft.Singularity
|
||
|
|
{
|
||
|
|
[NoCCtor]
|
||
|
|
[CLSCompliant(false)]
|
||
|
|
public class Kernel
|
||
|
|
{
|
||
|
|
private static string[] args;
|
||
|
|
private static ManualResetEvent mpEndEvent;
|
||
|
|
private static int bootReturnCode;
|
||
|
|
|
||
|
|
#region Waypoints
|
||
|
|
|
||
|
|
public static long[] Waypoints;
|
||
|
|
public static int[] WaypointSeq;
|
||
|
|
public static int[] WaypointThd;
|
||
|
|
public static int WaypointNumber;// = 0;
|
||
|
|
public static long WaypointSamples;// = 0;
|
||
|
|
public static bool WaypointSuspicious;
|
||
|
|
public static uint WaypointInterrupt;
|
||
|
|
public const int NWP = 2048; // XXX if this is readonly then it seems to read as 0!
|
||
|
|
|
||
|
|
[Conditional("WAYPOINTS")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void Waypoint0()
|
||
|
|
{
|
||
|
|
WaypointSamples++;
|
||
|
|
Waypoints[0] = (long)Processor.CycleCount;
|
||
|
|
WaypointNumber = 1;
|
||
|
|
WaypointSuspicious = false;
|
||
|
|
WaypointInterrupt = Processor.CurrentProcessor.NumInterrupts;
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("WAYPOINTS")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void Waypoint(int num)
|
||
|
|
{
|
||
|
|
if (Waypoints == null || Waypoints[0] == 0 || WaypointNumber > NWP-1) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
long delta = (long)Processor.CycleCount - Waypoints[0];
|
||
|
|
if (delta > 7000000) {
|
||
|
|
WaypointSuspicious = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
WaypointSeq[WaypointNumber] = num;
|
||
|
|
WaypointThd[WaypointNumber] = Thread.GetCurrentThreadIndex();
|
||
|
|
Waypoints[WaypointNumber++] = delta;
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("WAYPOINTS")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void WaypointDone()
|
||
|
|
{
|
||
|
|
Waypoints[0] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
#if false
|
||
|
|
[Conditional("WAYPOINTS")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void WaypointDump()
|
||
|
|
{
|
||
|
|
WaypointDump(NWP);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
[Conditional("WAYPOINTS")]
|
||
|
|
public static void WaypointDump()
|
||
|
|
{
|
||
|
|
bool iflag = Processor.DisableInterrupts();
|
||
|
|
|
||
|
|
DebugStub.WriteLine("Interrupts: {0}",
|
||
|
|
__arglist(Processor.CurrentProcessor.NumInterrupts
|
||
|
|
- WaypointInterrupt));
|
||
|
|
DebugStub.WriteLine("WPT Waypoint Sequence THD Diff");
|
||
|
|
|
||
|
|
for (int i = 1; i < WaypointNumber; i++) {
|
||
|
|
DebugStub.WriteLine("{0,3:d} {1,10:d} {2,10:d} {3,3:d} {4,10:d}",
|
||
|
|
__arglist(
|
||
|
|
i,
|
||
|
|
Waypoints[i],
|
||
|
|
WaypointSeq[i],
|
||
|
|
WaypointThd[i].GetHashCode(),
|
||
|
|
Waypoints[i] - Kernel.Waypoints[i-1]));
|
||
|
|
}
|
||
|
|
Processor.RestoreInterrupts(iflag);
|
||
|
|
}
|
||
|
|
|
||
|
|
[Conditional("WAYPOINTS")]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void WaypointReset()
|
||
|
|
{
|
||
|
|
for (int i = 0; i < NWP; i++) {
|
||
|
|
Waypoints[i] = 0;
|
||
|
|
}
|
||
|
|
WaypointSamples = 0;
|
||
|
|
}
|
||
|
|
#endregion // Waypoints
|
||
|
|
|
||
|
|
|
||
|
|
// Note: This function is called by Hal.cpp.
|
||
|
|
[AccessedByRuntime("referenced from hal.cpp")]
|
||
|
|
internal static int Main()
|
||
|
|
{
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_RESTART;
|
||
|
|
|
||
|
|
DebugStub.WriteLine("Kernel.Main()");
|
||
|
|
|
||
|
|
// Initialize the memory subsystem. This turns on paging!
|
||
|
|
MemoryManager.Initialize();
|
||
|
|
|
||
|
|
// Note for Monitoring early boot process:
|
||
|
|
// if you ever want to monitor stuff before this point, you should
|
||
|
|
// allocate a static memory area in BootInit.cs, init the
|
||
|
|
// monitoring system earlier, hold the system at this point here,
|
||
|
|
// copy over all the collected data up to now to the new
|
||
|
|
// dynamically created buffer and continue
|
||
|
|
Monitoring.Initialize(); // uses page memory
|
||
|
|
|
||
|
|
HandleTable.Initialize();
|
||
|
|
Stacks.Initialize();
|
||
|
|
|
||
|
|
try {
|
||
|
|
// Initialize the rest of the primitive runtime.
|
||
|
|
VTable.Initialize((RuntimeType)typeof(Kernel));
|
||
|
|
|
||
|
|
#if PAGING
|
||
|
|
// Must occur before MemoryManager.PostGCInitialize()
|
||
|
|
ProtectionDomain.Initialize();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// Must occur before SharedHeap.Initialize()
|
||
|
|
MemoryManager.PostGCInitialize();
|
||
|
|
|
||
|
|
SharedHeap.Initialize();
|
||
|
|
|
||
|
|
#if PAGING
|
||
|
|
// Must occur after SharedHeap.Initialize();
|
||
|
|
ProtectionDomain.DefaultDomain.InitHook();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
args = GetCommandLine();
|
||
|
|
VTable.ParseArgs(args);
|
||
|
|
|
||
|
|
// Initialize the processor table.
|
||
|
|
InitType(typeof(Processor));
|
||
|
|
InitType(typeof(Scheduler));
|
||
|
|
InitType(typeof(MinScheduler));
|
||
|
|
|
||
|
|
Processor.InitializeProcessorTable();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "processor");
|
||
|
|
Processor processor = Processor.processorTable[0];
|
||
|
|
processor.Initialize(0);
|
||
|
|
|
||
|
|
PEImage.Initialize();
|
||
|
|
|
||
|
|
// initialize endpoints
|
||
|
|
InitType(typeof(Microsoft.Singularity.Channels.EndpointCore));
|
||
|
|
|
||
|
|
// get the system manifest
|
||
|
|
XmlReader xmlReader = new XmlReader(Binder.GetSystemManifest());
|
||
|
|
XmlNode xmlData = xmlReader.Parse();
|
||
|
|
XmlNode manifestRoot = xmlData.GetChild("system");
|
||
|
|
XmlNode initConfig = manifestRoot.GetChild("initConfig");
|
||
|
|
|
||
|
|
PerfCounters.Initialize();
|
||
|
|
// need to have processed the manifest before we can call Process initialize
|
||
|
|
PrincipalImpl.Initialize(initConfig);
|
||
|
|
Process.Initialize(manifestRoot.GetChild("processConfig"));
|
||
|
|
|
||
|
|
|
||
|
|
// obtain the configuration for the namespace service
|
||
|
|
// and initialize the namespace service
|
||
|
|
DirectoryService.Initialize(initConfig);
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "IoSystem");
|
||
|
|
IoSystem.Initialize(
|
||
|
|
manifestRoot.GetChild("drivers"));
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Registering HAL Drivers.");
|
||
|
|
Devices.RegisterPnpResources(); // add the root device
|
||
|
|
|
||
|
|
HalDevices.Initialize(processor); //
|
||
|
|
|
||
|
|
#if SINGULARITY_MP
|
||
|
|
// haryadi -- at this point we have the SRAT table,
|
||
|
|
// Create per-processor address space now
|
||
|
|
MemoryManager.InitializeProcessorAddressSpace();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// From here on, we want lazy type initialization to worry about
|
||
|
|
// competing threads.
|
||
|
|
VTable.InitializeForMultipleThread();
|
||
|
|
|
||
|
|
Console.WriteLine("Running C# Kernel of {0}", GetLinkDate());
|
||
|
|
|
||
|
|
Console.WriteLine();
|
||
|
|
|
||
|
|
Console.WriteLine("Initializing Scheduler");
|
||
|
|
MinScheduler.Initialize(Process.idleProcess);
|
||
|
|
|
||
|
|
|
||
|
|
DirectoryService.StartNotificationThread();
|
||
|
|
|
||
|
|
Console.WriteLine("Initializing Shared Heap Walker");
|
||
|
|
Process.InitializeSharedHeapWalker();
|
||
|
|
|
||
|
|
Console.WriteLine("Initializing Service Thread");
|
||
|
|
ServiceThread.Initialize();
|
||
|
|
|
||
|
|
#if GENERATE_ABI_SHIM
|
||
|
|
// haryadi: add Ap service thread
|
||
|
|
Console.WriteLine("Initializing AP Service Thread");
|
||
|
|
ApServiceThread.Initialize();
|
||
|
|
#endif
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Enabling GC Heap");
|
||
|
|
GC.EnableHeap();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Waypoints init");
|
||
|
|
Waypoints = new long[2048];
|
||
|
|
WaypointSeq = new int[2048];
|
||
|
|
WaypointThd = new int[2048];
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Interrupts ON.");
|
||
|
|
Processor.RestoreInterrupts(true);
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Starting Security Service channels");
|
||
|
|
PrincipalImpl.Export();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Creating Root Directory.");
|
||
|
|
IoSystem.InitializeDirectoryService();
|
||
|
|
// [TODO]turn off kernel interfaces to namespace here
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Binder");
|
||
|
|
Binder.Initialize(
|
||
|
|
manifestRoot.GetChild("namingConventions"));
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Creating console.");
|
||
|
|
ConsoleOutput.Initialize();
|
||
|
|
|
||
|
|
// Initialize MP after Binder and ConsoleOutput
|
||
|
|
// are initialized so there are no
|
||
|
|
// initialization races if the additional
|
||
|
|
// threads try to use them.
|
||
|
|
Tracing.Log(Tracing.Audit, "Starting additional processors");
|
||
|
|
MpExecution.Initialize();
|
||
|
|
mpEndEvent = new ManualResetEvent(false);
|
||
|
|
|
||
|
|
Processor.StartApProcessors();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Initializing Volume Manager.");
|
||
|
|
IoSystem.InitializeVolumeManager();
|
||
|
|
|
||
|
|
// Register drivers who depend on scheduling and resource
|
||
|
|
// management.
|
||
|
|
DebugStub.WriteLine("--- Registering Drivers ---------------------------");
|
||
|
|
Console.WriteLine("Registering Non-HAL Drivers.");
|
||
|
|
// register the metadata-based drivers
|
||
|
|
IoSystem.RegisterDrivers();
|
||
|
|
// register the internal kernel drivers
|
||
|
|
Devices.RegisterInternalDrivers();
|
||
|
|
NvPciLpcBridge.Register();
|
||
|
|
#if DEBUG
|
||
|
|
// and output the results
|
||
|
|
IoSystem.Dump(false);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
DebugStub.WriteLine("--- Activating Devices ----------------------------");
|
||
|
|
// now do device initialization
|
||
|
|
IoSystem.ActivateDrivers();
|
||
|
|
#if DEBUG
|
||
|
|
// and output the results
|
||
|
|
IoSystem.Dump(true);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Initializing Service Manager.");
|
||
|
|
IoSystem.InitializeServiceManager(manifestRoot.GetChild("serviceConfig"));
|
||
|
|
|
||
|
|
// Start up the kernel's diagnostics module
|
||
|
|
Console.WriteLine("Starting diagnostics module...");
|
||
|
|
Diagnostics.DiagnosticsModule.Initialize();
|
||
|
|
|
||
|
|
// Start up the kernel's stress test module
|
||
|
|
Console.WriteLine("Initializing stress module...");
|
||
|
|
Stress.StressService.Initialize();
|
||
|
|
|
||
|
|
Processor.StartSampling();
|
||
|
|
|
||
|
|
// Consider boot successful at this stage.
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_SHUTDOWN;
|
||
|
|
|
||
|
|
DebugStub.WriteLine("----------------------------------------------------------");
|
||
|
|
DebugStub.WriteLine("RdTsc, Halt, RdTsc");
|
||
|
|
ulong beg;
|
||
|
|
ulong end;
|
||
|
|
beg = Processor.CycleCount;
|
||
|
|
Processor.HaltUntilInterrupt();
|
||
|
|
end = Processor.CycleCount;
|
||
|
|
|
||
|
|
DebugStub.WriteLine(" Begin: {0,16:d}", __arglist(beg));
|
||
|
|
DebugStub.WriteLine(" End: {0,16:d}", __arglist(end));
|
||
|
|
DebugStub.WriteLine(" Diff: {0,16:d}", __arglist(end - beg));
|
||
|
|
DebugStub.WriteLine("----------------------------------------------------------");
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Creating Shell Process");
|
||
|
|
int exit = -10000;
|
||
|
|
Process process = null;
|
||
|
|
IoMemory memory;
|
||
|
|
Manifest manifest;
|
||
|
|
|
||
|
|
#if KERNEL_USE_LOGIN
|
||
|
|
if (args[0] == "bvt") {
|
||
|
|
memory = Binder.LoadImage(Thread.CurrentProcess, "tty.x86", out manifest);
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
// TODO: The login app needs to be fixed to setup stdin and stdout pipes for
|
||
|
|
// the shell and pump the data back and forth.
|
||
|
|
memory = Binder.LoadImage(Thread.CurrentProcess, "login.x86", out manifest);
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
memory = Binder.LoadImage(Thread.CurrentProcess, "tty.x86", out manifest);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
if (memory != null && memory.Length > 0) {
|
||
|
|
String[] shellArgs = new String[args.Length + 2];
|
||
|
|
shellArgs[0] = "tty.x86";
|
||
|
|
shellArgs[1] = "shell.x86";
|
||
|
|
for (int i = 0; i < args.Length; i++) {
|
||
|
|
shellArgs[i + 2] = args[i];
|
||
|
|
}
|
||
|
|
process = new Process(Thread.CurrentProcess, memory, null, shellArgs, manifest);
|
||
|
|
if (process != null) {
|
||
|
|
process.Start();
|
||
|
|
process.Join();
|
||
|
|
exit = process.ExitCode;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (exit) {
|
||
|
|
case -10000:
|
||
|
|
Tracing.Log(Tracing.Audit, "Failed to start shell process.");
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_RESTART;
|
||
|
|
break;
|
||
|
|
case BootInfo.EXIT_AND_WARMBOOT:
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_WARMBOOT;
|
||
|
|
break;
|
||
|
|
case BootInfo.EXIT_AND_RESTART:
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_RESTART;
|
||
|
|
break;
|
||
|
|
case BootInfo.EXIT_AND_SHUTDOWN:
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_SHUTDOWN;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Shutting down AP processors");
|
||
|
|
Processor.StopApProcessors();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Shutting down I/O system");
|
||
|
|
Console.WriteLine("Shutting down I/O system");
|
||
|
|
IoSystem.Finalize();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Interrupts OFF.");
|
||
|
|
Processor.DisableInterrupts();
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit, "Shutting down scheduler");
|
||
|
|
Console.WriteLine("Shutting down scheduler");
|
||
|
|
MinScheduler.Finalize();
|
||
|
|
|
||
|
|
// We should turn off interrupts here!
|
||
|
|
HalDevices.Finalize();
|
||
|
|
PEImage.Finalize();
|
||
|
|
|
||
|
|
DebugStub.WriteLine("Kernel Exiting [{0}]",
|
||
|
|
__arglist(bootReturnCode));
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
Tracing.Log(Tracing.Fatal, "Caught exception {0}", e.Message);
|
||
|
|
DebugStub.WriteLine("Caught {0}", __arglist(e.Message));
|
||
|
|
bootReturnCode = -1;
|
||
|
|
DebugStub.Break();
|
||
|
|
}
|
||
|
|
|
||
|
|
DebugStub.WriteLine("Kernel exiting with 0x{0:x4}",
|
||
|
|
__arglist(bootReturnCode));
|
||
|
|
|
||
|
|
Stacks.Finalize();
|
||
|
|
HandleTable.Finalize();
|
||
|
|
#if !PAGING
|
||
|
|
SharedHeap.Finalize();
|
||
|
|
#endif //PAGING
|
||
|
|
|
||
|
|
MemoryManager.Finalize();
|
||
|
|
|
||
|
|
if (bootReturnCode != BootInfo.EXIT_AND_WARMBOOT) {
|
||
|
|
Kill(bootReturnCode);
|
||
|
|
}
|
||
|
|
return bootReturnCode;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Note: This function is entry point to the managed
|
||
|
|
// kernel for CPU's other than the bootstrap processor.
|
||
|
|
// It is called by Hal.cpp.
|
||
|
|
[AccessedByRuntime("referenced from hal.cpp")]
|
||
|
|
internal static int MpMain(int cpu)
|
||
|
|
{
|
||
|
|
Tracing.Log(Tracing.Audit, "processor");
|
||
|
|
Processor processor = Processor.processorTable[cpu];
|
||
|
|
processor.Initialize(cpu);
|
||
|
|
HalDevices.Initialize(processor);
|
||
|
|
|
||
|
|
Processor.CurrentProcessor.SetNextTimerInterrupt(TimeSpan.Zero);
|
||
|
|
Processor.RestoreInterrupts(true);
|
||
|
|
|
||
|
|
Tracing.Log(Tracing.Audit,
|
||
|
|
"Halting processor until first interrupt.");
|
||
|
|
Processor.HaltUntilInterrupt();
|
||
|
|
Tracing.Log(Tracing.Audit, "Resumed from halt.");
|
||
|
|
|
||
|
|
// This probably won't be the
|
||
|
|
// ultimate way of dissociating kernel entry threads
|
||
|
|
// from the kernel.
|
||
|
|
mpEndEvent.WaitOne();
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// This function is called by the GC to locate all non-static object
|
||
|
|
// references allocated somewhere other than the stack.
|
||
|
|
internal static
|
||
|
|
void VisitSpecialData(System.GCs.NonNullReferenceVisitor visitor)
|
||
|
|
{
|
||
|
|
Process.VisitSpecialData(visitor);
|
||
|
|
visitor.VisitReferenceFields(Processor.processorTable);
|
||
|
|
}
|
||
|
|
|
||
|
|
// This function is called by GCs that move object to update all
|
||
|
|
// object references contained in non-objects (i.e. unsafe structs).
|
||
|
|
internal static void UpdateAfterGC(Thread currentThread)
|
||
|
|
{
|
||
|
|
Processor.UpdateAfterGC(currentThread);
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
||
|
|
[StackBound(8)]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static unsafe extern char * HalGetLinkDate();
|
||
|
|
|
||
|
|
internal static unsafe string GetLinkDate()
|
||
|
|
{
|
||
|
|
return new String(HalGetLinkDate());
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static unsafe string[] GetCommandLine()
|
||
|
|
{
|
||
|
|
String[] args =
|
||
|
|
(new String((char *)(BootInfo.HalGetBootInfo()->CmdLine32))).Split(null);
|
||
|
|
int dst = 0;
|
||
|
|
for (int src = 0; src < args.Length; src++) {
|
||
|
|
if (args[src] != null && args[src].Length > 0) {
|
||
|
|
args[dst++] = args[src];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (dst < args.Length) {
|
||
|
|
String[] list = new String[dst];
|
||
|
|
for (int i = 0; i < dst; i++) {
|
||
|
|
list[i] = args[i];
|
||
|
|
}
|
||
|
|
return list;
|
||
|
|
}
|
||
|
|
return args;
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void RequestWarmBoot()
|
||
|
|
{
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_WARMBOOT;
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void RequestRestart()
|
||
|
|
{
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_RESTART;
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static void RequestShutdown()
|
||
|
|
{
|
||
|
|
bootReturnCode = BootInfo.EXIT_AND_SHUTDOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
[MethodImpl(MethodImplOptions.InternalCall)]
|
||
|
|
[StackBound(1024)]
|
||
|
|
[NoHeapAllocation]
|
||
|
|
private static extern void Kill(int exitCode);
|
||
|
|
|
||
|
|
internal static void Shutdown(int exitCode)
|
||
|
|
{
|
||
|
|
unchecked {
|
||
|
|
Tracing.Log(Tracing.Audit, "Kernel.Shutdown({0})", (UIntPtr)(uint)exitCode);
|
||
|
|
}
|
||
|
|
DebugStub.WriteLine("Kernel.Shutdown(0x{0:x4})",
|
||
|
|
__arglist(exitCode));
|
||
|
|
DebugStub.Break();
|
||
|
|
VTable.Shutdown(exitCode);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static void Panic(string why)
|
||
|
|
{
|
||
|
|
DebugStub.WriteLine("KERNEL PANIC: {0}", __arglist(why));
|
||
|
|
Shutdown(BootInfo.EXIT_AND_HALT);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static UIntPtr AddressOf(Object o)
|
||
|
|
{
|
||
|
|
return Magic.addressOf(o);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static UIntPtr SizeOf(Object o)
|
||
|
|
{
|
||
|
|
return System.GCs.ObjectLayout.Sizeof(o);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static UIntPtr AddressOf(ITracked tracked)
|
||
|
|
{
|
||
|
|
return Magic.addressOf(tracked);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
unsafe public static UIntPtr AddressOf(void * ptr)
|
||
|
|
{
|
||
|
|
return (UIntPtr)ptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void InitType(Type ty)
|
||
|
|
{
|
||
|
|
VTable.initType((RuntimeType) ty);
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static string TypeName(Object o)
|
||
|
|
{
|
||
|
|
if (o == null) {
|
||
|
|
return "null";
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
Type t = o.GetType();
|
||
|
|
RuntimeType r = (RuntimeType)t;
|
||
|
|
return r.Name;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[NoHeapAllocation]
|
||
|
|
public static string TypeNameSpace(Object o)
|
||
|
|
{
|
||
|
|
if (o == null) {
|
||
|
|
return "null";
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
Type t = o.GetType();
|
||
|
|
RuntimeType r = (RuntimeType)t;
|
||
|
|
return r.Namespace;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static string FullTypeName(Object o)
|
||
|
|
{
|
||
|
|
if (o == null) {
|
||
|
|
return "null";
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
Type t = o.GetType();
|
||
|
|
RuntimeType r = (RuntimeType)t;
|
||
|
|
return r.Namespace + "." + r.Name;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void DumpPageTable()
|
||
|
|
{
|
||
|
|
System.GCs.PageTable.Dump("PageTable");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|