/base/Kernel/Singularity/Kernel.cs

///////////////////////////////////////////////////////////////////////////////

//

//  Microsoft Research Singularity

//

//  Copyright (c) Microsoft Corporation.  All rights reserved.

//

//  Note:

//

//  This file was modified since RDK 2.0 version.

//  Modifications:

//      2011-06-11: Marek Dzikiewicz

//



#define MEASURE_INIT_IO_PERFORMANCE



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.Directory;

using Microsoft.Singularity.Drivers;

using Microsoft.Singularity.Eventing;

using Microsoft.Singularity.Hal;

using Microsoft.Singularity.Io;

using Microsoft.Singularity.Loader;

using Microsoft.Singularity.Memory;

using Microsoft.Singularity.Scheduling;

using Microsoft.Singularity.Security;

using Microsoft.Singularity.V1.Services;

using Microsoft.Singularity.Xml;



[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)]

    [AccessedByRuntime("referenced from hal.cpp/hal.cpp")]

    public class Kernel

    {

        private static string[] args;

        private static ManualResetEvent mpEndEvent;

        private static int bootReturnCode;



        //  sample profiler kernel data

        public static uint ProfilerBufferSize;



#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 PBAR if this is readonly then it seems to read as 0!



        // This is temporary, until we get a HAL-based plug-and-play system going.

        public const byte       HalIpiInterrupt = 249;



        /// <summary> Flag indicating if kernel has succesfully booted </summary>

        private static bool             hasBooted;

        private static Scheduler        scheduler;



        ///

        /// <summary>

        ///     Property to find out if kernel finished booting

        /// </summary>

        ///

        public static bool HasBooted

        {

            [NoHeapAllocation]

            get

            {

                return hasBooted;

            }

        }



        /// <summary>

        ///     Get a default kernel scheduler

        /// </summary>

        internal static Scheduler TheScheduler

        {

            [Inline]

            [NoHeapAllocation]

            get

            {

                return scheduler;

            }

        }



        [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



        internal static DateTime BootTime;



        //        [System.Diagnostics.Conditional("ISA_ARM")]

        private static void ARM_PROGRESS(string msg)

        {

            DebugStub.WriteLine(msg);

        }



        [System.Diagnostics.Conditional("ISA_ARM")]

        private static void ARM_SPIN_FOREVER(string msg)

        {

            DebugStub.Assert(!Processor.InterruptsDisabled());

            Processor p = Processor.CurrentProcessor;



            DebugStub.WriteLine(msg);

            DateTime last = DateTime.Now;



            uint n = 0;



            while (true) {

                Thread.Sleep(1000);

            }

        }



        // Note: This function is called by Hal.cpp.

        [AccessedByRuntime("referenced from hal.cpp")]

        internal static int Main()

        {

            bootReturnCode = Platform.EXIT_AND_RESTART;

            InitPreMonitoring();

            try {

                InitServices();

                

                // Consider boot successful at this stage.

                bootReturnCode = Platform.EXIT_AND_SHUTDOWN;



                ARM_SPIN_FOREVER("kernel.arm Spinning forever");



                bootReturnCode = SpawnAndWaitForShell();

                // The shell has exited when we get here



                FinalizeServices();

            }

            catch (Exception e) {

                System.Console.WriteLine("EXCEPTION:: " + e.Message);

                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));

            FinalizePreMonitoring();

            if (bootReturnCode != Platform.EXIT_AND_WARMBOOT) {

                Kill(bootReturnCode);

            }

            return bootReturnCode;

        }



        private static void InitPreMonitoring()

        {

            Tracing.Log(0);

            Tracing.Log(1);

            Tracing.Log(2);

            Tracing.Log(3);

            DebugStub.WriteLine("-------------------------------------------------------------------------------");



            ARM_PROGRESS("Kernel!001");

            // Indicate that we are not booted yet

            hasBooted = false;



            // Rather than mark all bootstrap code with [NoBarriers], perform a mini-

            // initialization that gives us a working WriteBarrier.

            System.GCs.Barrier.PreInitialize();



            ARM_PROGRESS("Kernel!002");

            // Initialize the memory subsystem. If enabled 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

            ARM_PROGRESS("Kernel!003");

            HandleTable.Initialize();

        }



        private static void InitGCSupport()

        {

            ARM_PROGRESS("Kernel!004");

            // Initialize the rest of the primitive runtime.

            VTable.Initialize((RuntimeType)typeof(Kernel));

            ARM_PROGRESS("Kernel!005");

            // Must occur before MemoryManager.PostGCInitialize()

            ProtectionDomain.Initialize();

            ARM_PROGRESS("Kernel!006");

            // Must occur before SharedHeap.Initialize()

            MemoryManager.PostGCInitialize();

            ARM_PROGRESS("Kernel!007");

            // Allocates callback objects for stack growth

            Stacks.Initialize();

            ARM_PROGRESS("Kernel!008");

            // Initialize the HAL parts which require GC allocation

            Platform.ThePlatform.InitializeServices();

            ARM_PROGRESS("Kernel!009");

            SharedHeap.Initialize();

            ARM_PROGRESS("Kernel!010");

            // Must occur after SharedHeap.Initialize();

            ProtectionDomain.DefaultDomain.InitHook();

        }



        private static void InitServices()

        {

            InitGCSupport();

            args = GetCommandLine();

            VTable.ParseArgs(args);



            ARM_PROGRESS("Kernel!011");

            InitSchedulerTypes();



            ARM_PROGRESS("Kernel!018");

            Controller.InitializeSystem();

            Tracing.InitializeSystem();



            ARM_PROGRESS("Kernel!019");

            //  Read the profiler settings. The values are assumed in kbytes

            //  convert them to bytes for direct consumption

            ProfilerBufferSize = (uint)GetIntegerArgument("profiler", 0);

            ProfilerBufferSize *= 1024;



            ARM_PROGRESS("Kernel!020");



            SpinLock.StaticInitialize();



            int cpusLength;

            int cpuCount = GetCpuCount(out cpusLength);



            Processor.InitializeProcessorTable(cpusLength);

            ARM_PROGRESS("Kernel!021");

            Tracing.Log(Tracing.Audit, "processor");

            Processor processor = Processor.EnableProcessor(0);



            PEImage.Initialize();

            ARM_PROGRESS("Kernel!034");



            //  Initialize the sample profiling for the processor

            //  after the initial breakpoint in kd in the call

            //  PEImage.Initialize(). This will allow enabling profiling

            //  from kd, by overwriting the ProfilerBufferSize value

            processor.EnableProfiling();

            ARM_PROGRESS("Kernel!035");

            FlatPages.InitializeMemoryMonitoring();



            // initialize endpoints

            InitType(typeof(Microsoft.Singularity.Channels.EndpointCore));



            // TODO Bug 59: Currently broken, need to review paging build.

//#if PAGING

//            Microsoft.Singularity.Channels.EndpointTrusted.StaticInitialize();

//#endif

            ARM_PROGRESS("Kernel!036");



            // get the system manifest

            IoMemory systemManifest = GetSystemManifest();

            ARM_PROGRESS("Kernel!037");

            XmlReader xmlReader = new XmlReader(systemManifest);

            XmlNode xmlData = xmlReader.Parse();

            XmlNode manifestRoot = xmlData.GetChild("system");

            XmlNode initConfig = manifestRoot.GetChild("initConfig");

            ARM_PROGRESS("Kernel!038");



            PerfCounters.Initialize();

            // need to have processed the manifest before we can call Process initialize

            ARM_PROGRESS("Kernel!039");

            PrincipalImpl.Initialize(initConfig);



            ARM_PROGRESS("Kernel!040");

            Process.Initialize(manifestRoot.GetChild("processConfig"));



            InitIO(processor, initConfig, manifestRoot.GetChild("drivers"));



            InitBootTime();



            ARM_PROGRESS("Kernel!045");

            // From here on, we want lazy type initialization to worry about

            // competing threads.

            VTable.InitializeForMultipleThread();



            ARM_PROGRESS("Kernel!046");

            Console.WriteLine("Running C# Kernel of {0}", GetLinkDate());

            Console.WriteLine();



            // TODO: remove this

            Console.WriteLine("Current time: {0}", SystemClock.GetUtcTime().ToString("r"));

            ARM_PROGRESS("Kernel!047");



            InitScheduling();



            DirectoryService.StartNotificationThread();



            Console.WriteLine("Initializing Shared Heap Walker");

            ProtectionDomain.InitializeSharedHeapWalker();

            ARM_PROGRESS("Kernel!050");



            Console.WriteLine("Initializing Service Thread");

            ServiceThread.Initialize();

            ARM_PROGRESS("Kernel!051");



            GC.EnableHeap();

            GCProfilerLogger.StartProfiling();

            ARM_PROGRESS("Kernel!052");



            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);

            ARM_PROGRESS("Kernel!053");



#if ISA_ARM && TEST_GC

            for (int i = 0; i < 1000; i++) {

                DebugStub.WriteLine("Iteration {0}", __arglist(i));

                ArrayList a = new ArrayList();

                for (int j = 0; j < 128; j++) {

                    int size = 1024 * 1024;

                    a.Add(new byte [size]);

                }

            }

#endif // ISA_ARM



            ARM_PROGRESS("Kernel!054");



            Tracing.Log(Tracing.Audit, "Binder");

            Binder.Initialize(manifestRoot.GetChild("namingConventions"));



#if ISA_ARM

            DebugStub.WriteLine("Exporting local namespace to BSP\n");

            DirectoryService.ExportArmNamespace();

            DebugStub.WriteLine("Export complete...redirecting binder\n");

            Binder.RedirectRootRef();

            DebugStub.WriteLine("Binder redirect complete\n");

#endif



#if false

            Tracing.Log(Tracing.Audit, "Starting Security Service channels");

            PrincipalImpl.Export();

            ARM_PROGRESS("Kernel!055");

#endif

            Tracing.Log(Tracing.Audit, "Creating Root Directory.");



            //This can be moved below

            IoSystem.InitializeDirectoryService();

            ARM_PROGRESS("Kernel!055");



#if false

            // Start User space namespace manager

            Console.WriteLine("Starting Directory Service SIP");

            DirectoryService.StartUserSpaceDirectoryService();

#endif

            ARM_PROGRESS("Kernel!055.5");



#if !ISA_ARM

            Tracing.Log(Tracing.Audit, "Starting Security Service channels");

            PrincipalImpl.Export();

#endif



            ARM_PROGRESS("Kernel!056");



            Console.WriteLine("Initializing system channels");



            // starting channels services

            DebugStub.Print("Initializing Channel Services\n");

            ChannelDeliveryImplService.Initialize();



            ARM_PROGRESS("Kernel!057");

            ConsoleOutput.Initialize();



            ARM_PROGRESS("Kernel!058");



            // 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");



            // For ABI to ARM support

            MpExecution.Initialize();

            ARM_PROGRESS("Kernel!059");



            mpEndEvent = new ManualResetEvent(false);



            Tracing.Log(Tracing.Audit, "Initializing Volume Manager.");



#if !ISA_ARM

            IoSystem.InitializeVolumeManager();

#endif // ISA_ARM

            ARM_PROGRESS("Kernel!060");

            

#if MEASURE_INIT_IO_PERFORMANCE

            PerfSnap snap = new PerfSnap();

            snap.Start();

#endif



            InitDrivers();



#if MEASURE_INIT_IO_PERFORMANCE

            snap.Finish(1);

            snap.DisplaySimple();

#endif



            if (cpuCount > 1) {

                unsafe {

                    Console.WriteLine("Enabling {0} cpus out of {1} real cpus\n", cpuCount, Platform.ThePlatform.CpuRealCount);

                }

                Processor.EnableMoreProcessors(cpuCount);

                ARM_PROGRESS("Kernel!064");

            }



            Tracing.Log(Tracing.Audit, "Initializing Service Manager.");

            IoSystem.InitializeServiceManager(manifestRoot.GetChild("serviceConfig"));

            ARM_PROGRESS("Kernel!065");



            InitDiagnostics();



#if !ISA_ARM

            // At this point consider kernel finshed booting

            hasBooted = true;

#endif // ISA_ARM



            Processor.StartSampling();

            ARM_PROGRESS("Kernel!069");



            Microsoft.Singularity.KernelDebugger.KdFilesNamespace.StartNamespaceThread();

            ARM_PROGRESS("Kernel!070");



        }



        private static void InitSchedulerTypes()

        {

            InitType(typeof(Processor));

            InitType(typeof(Scheduler));

            InitType(typeof(ProcessorDispatcher));

            // InitType(typeof(AffinityScheduler));

            InitType(typeof(MinScheduler));



            ARM_PROGRESS("Kernel!013");

            // Create scheduler before initializing processes

            scheduler = new MinScheduler();



            ARM_PROGRESS("Kernel!017");

            // Initialize processor dispatcher

            ProcessorDispatcher.StaticInitialize(scheduler);

        }



        private static void InitScheduling()

        {

            Console.WriteLine("Initializing Scheduler");



            ARM_PROGRESS("Kernel!047");

            // Finish scheduler initialization:

            scheduler.Initialize();

            ARM_PROGRESS("Kernel!048");



            // Initialize initial dispatcher

            Processor.InitializeDispatcher(0);

            Processor.ActivateTimer(0);

            ARM_PROGRESS("Kernel!049");

        }



        private static void InitIO(Processor p, XmlNode initConfig, XmlNode driverConfig)

        {

            // obtain the configuration for the namespace service

            // and initialize the namespace service

            ARM_PROGRESS("Kernel!041");

            DirectoryService.Initialize(initConfig);



            Tracing.Log(Tracing.Audit, "IoSystem");

            ARM_PROGRESS("Kernel!042");

            IoSystem.Initialize(driverConfig);



            Tracing.Log(Tracing.Audit, "Registering HAL Drivers.");



            ARM_PROGRESS("Kernel!043");



            Devices.RegisterPnpResources(); // add the root devices



            ARM_PROGRESS("Kernel!044");



            Platform.InitializeHal(p);

        }



        private static int SpawnAndWaitForShell()

        {



#if ISA_ARM

            // spin here for now

            while (true) {

                Thread.Yield();

            }

#else



            Tracing.Log(Tracing.Audit, "Creating Shell Process");

            ARM_PROGRESS("Kernel!071");

            int exit = -10000;

            Manifest manifest;

#if KERNEL_USE_LOGIN

            IoMemory memory;

            if (args[0] == "bvt") {

                memory = Binder.LoadImage(Thread.CurrentProcess, "tty", 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", out manifest);

            }

#else

            IoMemory memory = Binder.LoadImage(Thread.CurrentProcess, "tty", out manifest);

#endif

            ARM_PROGRESS("Kernel!073");



            if (memory == null || memory.Length > 0) {

                String[] shellArgs = new String[args.Length + 2];

                shellArgs[0] = "tty";

                shellArgs[1] = "shell";

                for (int i = 0; i < args.Length; i++) {

                    shellArgs[i + 2] = args[i];

                }

                Process process = new Process(Thread.CurrentProcess, memory, null, shellArgs, manifest);

                if (process != null) {

                    PrintBootTime();

                    process.Start();

                    process.Join();

                    exit = process.ExitCode;

                }



                ARM_PROGRESS("Kernel!074");

            }

            return DetermineShutdown(exit);

#endif

        }



        private static int DetermineShutdown(int exit)

        {

            switch (exit) {

                case -10000:

                    Tracing.Log(Tracing.Audit, "Failed to start shell process.");

                    return Platform.EXIT_AND_RESTART;

                case Platform.EXIT_AND_WARMBOOT:

                case Platform.EXIT_AND_RESTART:

                case Platform.EXIT_AND_SHUTDOWN:

                    return exit;

                default:

                    DebugStub.WriteLine("Shell process terminated improperly (0x{0:x4})",

                                        __arglist(exit));

                    Tracing.Log(Tracing.Audit, "Shell process terminated improperly");

                    DebugStub.Break();

                    return Platform.EXIT_AND_SHUTDOWN;

            }

        }



        private static void InitBootTime()

        {

            if (Platform.ThePlatform.BootYear != 0) {

                BootTime = new DateTime((int)Platform.ThePlatform.BootYear,

                                        (int)Platform.ThePlatform.BootMonth,

                                        (int)Platform.ThePlatform.BootDay,

                                        (int)Platform.ThePlatform.BootHour,

                                        (int)Platform.ThePlatform.BootMinute,

                                        (int)Platform.ThePlatform.BootSecond,

                                        0);

                //  There is no time zone support in Singularity, the clock assumes GMT

                //  but the CMOS reports it in local time. Hardcode the correction here for now

                BootTime = BootTime.AddHours(8);

            }

            else {

                //  Other HALs do not capture the load time. Make the best effort to

                //  capture now, after the devices are initialized.

                BootTime = DateTime.Now;

            }

        }



        private static void InitDrivers()

        {

            // 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();

            ARM_PROGRESS("Kernel!061");



            // register the internal kernel drivers

            Devices.RegisterInternalDrivers();

            ARM_PROGRESS("Kernel!062");

#if DEBUG

            // and output the results

            IoSystem.Dump(false);

#endif

            DebugStub.WriteLine("--- Activating Devices ----------------------------");

            // now do device initialization

            IoSystem.ActivateDrivers();

            ARM_PROGRESS("Kernel!063");

#if DEBUG

            // and output the results

            // IoSystem.Dump(true);

#endif

        }



        private static void InitDiagnostics()

        {

            // Start up the kernel's diagnostics module

            Console.WriteLine("Starting diagnostics module...");

            Diagnostics.DiagnosticsModule.Initialize();

            ARM_PROGRESS("Kernel!066");

            // Start up the kernel's stress test module

            Console.WriteLine("Initializing stress module...");

            Stress.StressService.Initialize();

            ARM_PROGRESS("Kernel!067");

        }



        private static IoMemory GetSystemManifest()

        {

            IoMemory res = Binder.GetSystemManifest();

            if (res == null) {

                DebugStub.WriteLine("Failed to load system manifest.");

                DebugStub.Break();

                throw new Exception("The system manifest could not be loaded.");

            }

            return res;

        }



        private static void FinalizeServices()

        {

            ARM_PROGRESS("Kernel!075");

            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");

            for (int i = 0; i < Processor.processorTable.Length; i++) {

                Processor p = Processor.processorTable[i];

                if (p != null) {

                    Console.WriteLine("  cpu {0}: {1} context switches, {2} interrupts", i, p.NumContextSwitches, p.NumInterrupts);

                }

            }



            // Finalize the scheduler

            scheduler.Finalize();



            // We should turn off interrupts here!

            Platform.ReleaseResources();

            PEImage.Finalize();



            DebugStub.WriteLine("Kernel Exiting [{0}]",

                                __arglist(bootReturnCode));

        }



        private static void FinalizePreMonitoring()

        {

            Stacks.Finalize();

            HandleTable.Finalize();

            SharedHeap.Finalize();

            MemoryManager.Finalize();

        }



        private static int GetCpuCount(out int cpusLength)

        {

            int cpuReal = Platform.ThePlatform.CpuRealCount;

            int cpuLimit = Platform.ThePlatform.CpuMaxCount;

            DebugStub.Assert(cpuReal <= cpuLimit);



            // See if the command line argument limits our processor count

            int cpuCount = GetIntegerArgument("mp", cpuReal);

            cpusLength = cpuReal;



#if !SINGULARITY_MP

            if (cpuCount > 1) {

                Console.WriteLine("Limiting processors to 1 due to SP build");

                cpuCount = 1;

            }

#endif

            return cpuCount;

        }



        // Note: This function is entry point to the managed

        // kernel for CPU's other than the bootstrap processor.

        // It is called from the Hal or Hal.

        [AccessedByRuntime("referenced from hal.cpp")]

        internal static int MpMain(int cpu)

        {

            Tracing.Log(Tracing.Audit, "processor");

            Processor processor = Processor.EnableProcessor(cpu);



            // Initialize dispatcher

            Processor.InitializeDispatcher(cpu);



            // Initialize the HAL processor services

            // Note that this must occur after EnableProcessor, as the kernel

            // thread does not get bound until then. (It gets bound much

            // earlier in the boot processor case -- need to decide if this difference is

            // really appropriate.)

            Platform.Cpu(cpu).InitializeServices();



            Platform.InitializeHal(processor);



            Thread.CurrentThread.Affinity = cpu;



            Processor.ActivateTimer(cpu);



#if DEBUG_SYSTEM_LOCKUP

            // Spin one CPU on debugger. For instance with a quad-proc

            // box, spin CPU 3.

            while (cpu == 3) {

                if (DebugStub.PollForBreak() == true) {

                    DebugStub.Break();

                }

            }

#endif // DEBUG_SYSTEM_LOCKUP



            Processor.RestoreInterrupts(true);



            Tracing.Log(Tracing.Audit,

                        "Looping in processor's kernel thread.");

            //while (cpu > 0) {

            //    Thread.Yield();

            //}



            // This probably won't be the

            // ultimate way of dissociating kernel entry threads

            // from the kernel.

            DebugStub.Print("AP Processor started, about to wait\n");

            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.DirectReferenceVisitor visitor)

        {

            Platform.ThePlatform.VisitSpecialData(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);

        }



        [AccessedByRuntime("defined in HAL.cpp")]

        [MethodImpl(MethodImplOptions.InternalCall)]

        [StackBound(256)]

        [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 *)(Platform.ThePlatform.CommandLine),

                            0, Platform.ThePlatform.CommandLineCount)).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;

        }



        // kind the argument "key" and extract the string value following a colon.

        internal static string

        GetStringArgument(string key, string defaultValue)

        {

            key = key + ":";

            for (int i = 0; i < args.Length; i++) {

                string arg = args[i];

                if ((arg.StartsWith("-") || arg.StartsWith("/")) &&

                    0 == String.Compare(arg, 1, key, 0, key.Length, true)) {

                    string result = arg.Substring(key.Length+1);

                    string[] newargs = new string[args.Length - 1];

                    Array.Copy(args, 0, newargs, 0, i);

                    Array.Copy(args, i + 1, newargs, i, args.Length - i - 1);

                    args = newargs;

                    return result;

                }

            }

            return defaultValue;

        }



        internal static int GetIntegerArgument(string key, int defaultValue)

        {

            key = key + ":";

            for (int i = 0; i < args.Length; i++) {

                string arg = args[i];

                if ((arg.StartsWith("-") || arg.StartsWith("/")) &&

                    0 == String.Compare(arg, 1, key, 0, key.Length, true)) {

                    string result = arg.Substring(key.Length+1);

                    string[] newargs = new string[args.Length - 1];

                    Array.Copy(args, 0, newargs, 0, i);

                    Array.Copy(args, i + 1, newargs, i, args.Length - i - 1);

                    args = newargs;

                    // TODO this should be try-parse

                    return Int32.Parse(result);

                }

            }

            return defaultValue;

        }



        [NoHeapAllocation]

        public static void RequestWarmBoot()

        {

            bootReturnCode = Platform.EXIT_AND_WARMBOOT;

        }



        [NoHeapAllocation]

        public static void RequestRestart()

        {

            bootReturnCode = Platform.EXIT_AND_RESTART;

        }



        [NoHeapAllocation]

        public static void RequestShutdown()

        {

            bootReturnCode = Platform.EXIT_AND_SHUTDOWN;

        }



        private static void Kill(int exitCode)

        {

            Platform.ThePlatform.Kill(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);

        }



        // Rationale for cutting the fact that no stack probes are permitted in this

        // tree of calls:

        //

        // * We are already hosed.

        // * Without this cut, places that cannot (transitively) tolerate stack link extensions

        // * cannot call Panic.

        [NoStackLinkCheckTransCut][IgnoreLockRank]

        internal static void Panic(string why)

        {

            DebugStub.WriteLine("KERNEL PANIC: {0}", __arglist(why));

            Shutdown(Platform.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");

        }



        internal static void PrintBootTime()

        {

            // Console.WriteLine("Current time: {0}", SystemClock.GetUtcTime().ToString("r"));

            // Console.WriteLine("Boot time: {0}", BootTime.ToString("r"));



            TimeSpan delta = SystemClock.GetUtcTime() - BootTime;

            DebugStub.WriteLine("Elapsed boot time = {0} msec.", __arglist(delta.TotalMilliseconds));

        }

    }

}