public static void DBGERR(FOS_System.String testName, FOS_System.String msg) { BasicConsole.SetTextColour(BasicConsole.error_colour); DBGMSG(testName, msg); BasicConsole.SetTextColour(BasicConsole.default_colour); errors++; }
private static void EnterCritical(FOS_System.String caller) { //BasicConsole.WriteLine("Entering critical section..."); if (AccessLockInitialised) { if (AccessLock == null) { BasicConsole.WriteLine("HeapAccessLock is initialised but null?!"); BasicConsole.DelayOutput(10); } else { if (AccessLock.Locked && OutputTrace) { BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("Warning: Heap about to try to re-enter spin lock..."); BasicConsole.Write("Enter lock caller: "); BasicConsole.WriteLine(caller); BasicConsole.SetTextColour(BasicConsole.default_colour); } AccessLock.Enter(); } } //else //{ // BasicConsole.WriteLine("HeapAccessLock not initialised - ignoring lock conditions."); // BasicConsole.DelayOutput(5); //} }
/// <summary> /// Outputs, via the basic console, how much memory was cleaned up. /// </summary> /// <param name="startNumObjs">The number of objects before the cleanup.</param> /// <param name="startNumStrings">The number of strings before the cleanup.</param> private static void PrintCleanupData(int startNumObjs, int startNumStrings) { int numObjsFreed = startNumObjs - NumObjs; int numStringsFreed = startNumStrings - NumStrings; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(((FOS_System.String)"Freed objects: ") + numObjsFreed); BasicConsole.WriteLine(((FOS_System.String)"Freed strings: ") + numStringsFreed); BasicConsole.WriteLine(((FOS_System.String)"Used memory : ") + (Heap.FBlock->used * Heap.FBlock->bsize) + " / " + Heap.FBlock->size); BasicConsole.DelayOutput(2); BasicConsole.SetTextColour(BasicConsole.default_colour); }
public static void UpdateCurrentState() { #if SCHEDULER_HANDLER_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); if (Processes.ProcessManager.Processes.Count > 1) { BasicConsole.WriteLine("Scheduler interrupt started..."); } #endif if (ProcessManager.CurrentProcess == null || ProcessManager.CurrentThread == null || ProcessManager.CurrentThread_State == null) { return; } UpdateInactiveThreads(); UpdateActiveThreads(); while (ActiveQueue.Count == 0) { //#if SCHEDULER_HANDLER_TRACE BasicConsole.WriteLine("WARNING: Scheduler preventing infinite loop by early-updating sleeping threads."); //#endif UpdateInactiveThreads(); } Thread nextThread = (Thread)ActiveQueue.PeekMin(); #if SCHEDULER_HANDLER_TRACE || SCHEDULER_HANDLER_MIN_TRACE BasicConsole.Write("Active: "); BasicConsole.Write(nextThread.Owner.Name); BasicConsole.Write(" - "); BasicConsole.WriteLine(nextThread.Name); #endif ProcessManager.SwitchProcess(nextThread.Owner.Id, (int)nextThread.Id); if (!ProcessManager.CurrentThread_State->Started) { SetupThreadForStart(); } #if SCHEDULER_HANDLER_TRACE if (Processes.ProcessManager.Processes.Count > 1) { BasicConsole.WriteLine("Scheduler interrupt ended."); } BasicConsole.SetTextColour(BasicConsole.default_colour); #endif }
public static void Main() { while (!Terminate) { //bool reenable = Hardware.Processes.Scheduler.Enabled; try { //if (reenable) //{ // Hardware.Processes.Scheduler.Disable(); //} #if GCTASK_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.Write("GC cleaning..."); BasicConsole.WriteLine(Hardware.Processes.ProcessManager.CurrentProcess.Name); BasicConsole.SetTextColour(BasicConsole.default_colour); #endif FOS_System.GC.Cleanup(); #if GCTASK_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("GC stopped (1)."); BasicConsole.SetTextColour(BasicConsole.default_colour); #endif } catch { #if GCTASK_TRACE BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("GC error."); BasicConsole.SetTextColour(BasicConsole.default_colour); #endif } #if GCTASK_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("GC stopped (2)."); BasicConsole.SetTextColour(BasicConsole.default_colour); #endif //if (reenable) //{ // Hardware.Processes.Scheduler.Enable(); //} Processes.SystemCalls.SleepThread(1000); } }
public static void _IncrementRefCount(byte* objPtr) { if ((uint)objPtr < (uint)sizeof(GCHeader)) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't increment ref count of an object in low memory."); uint* basePtr = (uint*)ExceptionMethods.BasePointer; // Go up the linked-list of stack frames to (hopefully) the outermost caller basePtr = (uint*)*(basePtr); // Frame of IncrementRefCount(x) uint retAddr = *(basePtr + 1); // Caller of IncrementRefCount(x) basePtr = (uint*)*(basePtr); // Frame of caller of IncrementRefCount(x) uint ret2Addr = *(basePtr + 1); // Caller of caller of IncrementRefCount(x) uint objAddr = (uint)objPtr; String msgStr = "Caller: 0x , Object: 0x , PCaller: 0x "; // Object: 37 // Caller: 17 // PCaller: 58 ExceptionMethods.FillString(retAddr, 17, msgStr); ExceptionMethods.FillString(objAddr, 37, msgStr); ExceptionMethods.FillString(ret2Addr, 58, msgStr); BasicConsole.WriteLine(msgStr); BasicConsole.DelayOutput(5); BasicConsole.SetTextColour(BasicConsole.default_colour); } objPtr -= sizeof(GCHeader); GCHeader* gcHeaderPtr = (GCHeader*)objPtr; if (CheckSignature(gcHeaderPtr)) { gcHeaderPtr->RefCount++; if (gcHeaderPtr->RefCount > 0) { RemoveObjectToCleanup(gcHeaderPtr); } } }
public static void Main() { OwnerThread = ProcessManager.CurrentThread; Kernel.Processes.SystemCalls.SleepThread(Kernel.Processes.SystemCalls.IndefiniteSleepThread); while (!Terminate) { Awake = false; DeviceManager.UpdateDevices(); if (!Awake) { if (Kernel.Processes.SystemCalls.SleepThread(Kernel.Processes.SystemCalls.IndefiniteSleepThread) != Kernel.Processes.SystemCallResults.OK) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Failed to sleep device manager thread!"); BasicConsole.SetTextColour(BasicConsole.default_colour); } } } }
public static void _IncrementRefCount(byte *objPtr) { if ((uint)objPtr < (uint)sizeof(GCHeader)) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't increment ref count of an object in low memory."); BasicConsole.DelayOutput(5); BasicConsole.SetTextColour(BasicConsole.default_colour); } objPtr -= sizeof(GCHeader); GCHeader *gcHeaderPtr = (GCHeader *)objPtr; if (CheckSignature(gcHeaderPtr)) { gcHeaderPtr->RefCount++; if (gcHeaderPtr->RefCount > 0) { RemoveObjectToCleanup(gcHeaderPtr); } } }
public static void Main() { OwnerThread = ProcessManager.CurrentThread; Thread.Sleep_Indefinitely(); while (!Terminate) { Awake = false; DeviceManager.UpdateDevices(); if (!Awake) { if (!Thread.Sleep_Indefinitely()) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Failed to sleep device manager thread!"); BasicConsole.SetTextColour(BasicConsole.default_colour); } } } }
public static void *Alloc(UInt32 size, UInt32 boundary, FOS_System.String caller) { #if HEAP_TRACE if (OutputTrace) { BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("Attempt to alloc mem...."); BasicConsole.SetTextColour(BasicConsole.default_colour); } #endif if (PreventAllocation) { bool BCPOEnabled = BasicConsole.PrimaryOutputEnabled; BasicConsole.PrimaryOutputEnabled = true; BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.Write("Allocation of memory prevented! Reason: "); BasicConsole.WriteLine(PreventReason); BasicConsole.Write(" > Caller: "); BasicConsole.WriteLine(caller); BasicConsole.DelayOutput(5); BasicConsole.SetTextColour(BasicConsole.default_colour); BasicConsole.PrimaryOutputEnabled = BCPOEnabled; return(null); } EnterCritical("Alloc"); HeapBlock *b; byte * bm; UInt32 bcnt; UInt32 x, y, z; UInt32 bneed; byte nid; if (boundary > 1) { size += (boundary - 1); } /* iterate blocks */ for (b = fblock; (UInt32)b != 0; b = b->next) { /* check if block has enough room */ if (b->size - (b->used * b->bsize) >= size) { bcnt = b->size / b->bsize; bneed = (size / b->bsize) * b->bsize < size ? size / b->bsize + 1 : size / b->bsize; bm = (byte *)&b[1]; for (x = (b->lfb + 1 >= bcnt ? 0 : b->lfb + 1); x != b->lfb; ++x) { /* just wrap around */ if (x >= bcnt) { x = 0; } if (bm[x] == 0) { /* count free blocks */ for (y = 0; bm[x + y] == 0 && y < bneed && (x + y) < bcnt; ++y) { ; } /* we have enough, now allocate them */ if (y == bneed) { /* find ID that does not match left or right */ nid = GetNID(bm[x - 1], bm[x + y]); /* allocate by setting id */ for (z = 0; z < y; ++z) { bm[x + z] = nid; } /* optimization */ b->lfb = (x + bneed) - 2; /* count used blocks NOT bytes */ b->used += y; void *result = (void *)(x * b->bsize + (UInt32)(&b[1])); if (boundary > 1) { result = (void *)((((UInt32)result) + (boundary - 1)) & ~(boundary - 1)); //#if HEAP_TRACE // ExitCritical(); // BasicConsole.WriteLine(((FOS_System.String)"Allocated address ") + (uint)result + " on boundary " + boundary + " for " + caller); // EnterCritical("Alloc:Boundary condition"); //#endif } ExitCritical(); return(result); } /* x will be incremented by one ONCE more in our FOR loop */ x += (y - 1); continue; } } } } { bool BCPOEnabled = BasicConsole.PrimaryOutputEnabled; BasicConsole.PrimaryOutputEnabled = true; BasicConsole.Write("Heap ("); BasicConsole.Write(name); BasicConsole.WriteLine(") out of memory!"); if (fblock == null) { BasicConsole.WriteLine(" !! fblock == null"); } else if (GetTotalFreeMem() < size) { if (GetTotalMem() == 0) { BasicConsole.WriteLine(" !! Out of free mem because total mem is zero."); } else if (GetTotalMem() <= 8092) { BasicConsole.WriteLine(" !! Out of free mem because total mem is <= 8092 bytes."); } else { BasicConsole.WriteLine(" !! Genuinely out of memory."); } } BasicConsole.PrimaryOutputEnabled = BCPOEnabled; } ExitCritical(); return(null); }
public static void Test_qTDWrapper() { FOS_System.String testName = "Queue Transfer Descrip"; DBGMSG(testName, "START"); errors = 0; warnings = 0; EHCI_qTD qTD = new EHCI_qTD(); try { byte *pqTD = (byte *)qTD.qtd; //Verifications done via two methods: // 1. Check value from pointer & manual shifting to confirm set properly // 2. Check value from "get" method to confirm reading properly // 3. For boolean types, also test & verify setting to false! qTD.AlternateNextqTDPointerTerminate = true; if ((pqTD[0x04u] & 0x01u) == 0) { DBGERR(testName, "AlternateNextqTDPointerTerminate - Failed to set to true."); } else { if (!qTD.AlternateNextqTDPointerTerminate) { DBGERR(testName, "AlternateNextqTDPointerTerminate - Failed to read as true."); } else { pqTD[0x04u] = 0xFF; qTD.AlternateNextqTDPointerTerminate = false; if ((pqTD[0x04u] & 0x1u) != 0) { DBGERR(testName, "AlternateNextqTDPointerTerminate - Failed to set to false."); } else { if (qTD.AlternateNextqTDPointerTerminate) { DBGERR(testName, "AlternateNextqTDPointerTerminate - Failed to read as false."); } } } } qTD.Buffer0 = (byte *)0xDEADBEEFu; //Read back should be 0xDEADB000 if ((pqTD[0x0Du] & 0xF0u) != 0xB0u || pqTD[0x0Eu] != 0xADu || pqTD[0x0Fu] != 0xDEu) { DBGERR(testName, "Buffer0 - Failed to set."); } else { if ((uint)qTD.Buffer0 != 0xDEADB000u) { DBGERR(testName, "Buffer0 - Failed to read."); } } qTD.Buffer1 = (byte *)0x12345678u; //Read back should be 0x12345000 if ((pqTD[0x11u] & 0xF0u) != 0x50u || pqTD[0x12u] != 0x34u || pqTD[0x13u] != 0x12u) { DBGERR(testName, "Buffer1 - Failed to set."); } else { if ((uint)qTD.Buffer1 != 0x12345000u) { DBGERR(testName, "Buffer1 - Failed to read."); } } qTD.Buffer2 = (byte *)0xFEEDBEA5u; //Read back should be 0xFEEDB000 if ((pqTD[0x15u] & 0xF0u) != 0xB0u || pqTD[0x16u] != 0xEDu || pqTD[0x17u] != 0xFEu) { DBGERR(testName, "Buffer2 - Failed to set."); } else { if ((uint)qTD.Buffer2 != 0xFEEDB000u) { DBGERR(testName, "Buffer2 - Failed to read."); } } qTD.Buffer3 = (byte *)0x09876543u; //Read back should be 0x09876000 if ((pqTD[0x19u] & 0xF0u) != 0x60u || pqTD[0x1Au] != 0x87u || pqTD[0x1Bu] != 0x09u) { DBGERR(testName, "Buffer3 - Failed to set."); } else { if ((uint)qTD.Buffer3 != 0x09876000u) { DBGERR(testName, "Buffer3 - Failed to read."); } } qTD.Buffer4 = (byte *)0x24681357u; //Read back should be 0x24681000 if ((pqTD[0x1Du] & 0xF0u) != 0x10u || pqTD[0x1Eu] != 0x68u || pqTD[0x1Fu] != 0x24u) { DBGERR(testName, "Buffer4 - Failed to set."); } else { if ((uint)qTD.Buffer4 != 0x24681000u) { DBGERR(testName, "Buffer4 - Failed to read."); } } qTD.CurrentPage = 0xFF; //Shift! if ((pqTD[0x09u] & 0x70u) != 0x70u) { DBGERR(testName, "CurrentPage - Failed to set."); } else { if ((uint)qTD.CurrentPage != 0x07u) { DBGERR(testName, "CurrentPage - Failed to read."); } } qTD.DataToggle = true; if ((pqTD[0x0Bu] & 0x80u) == 0) { DBGERR(testName, "DataToggle - Failed to set to true."); } else { if (!qTD.DataToggle) { DBGERR(testName, "DataToggle - Failed to read as true."); } else { pqTD[0x0Bu] = 0xFF; qTD.DataToggle = false; if ((pqTD[0x0Bu] & 0x80u) != 0) { DBGERR(testName, "DataToggle - Failed to set to false."); } else { if (qTD.DataToggle) { DBGERR(testName, "DataToggle - Failed to read as false."); } } } } qTD.ErrorCounter = 0xFF; //Shift! if ((pqTD[0x09u] & 0x0Cu) != 0x0Cu) { DBGERR(testName, "ErrorCounter - Failed to set."); } else { if ((uint)qTD.ErrorCounter != 0x03u) { DBGERR(testName, "ErrorCounter - Failed to read."); } } qTD.InterruptOnComplete = true; if ((pqTD[0x09u] & 0x80u) == 0) { DBGERR(testName, "InterruptOnComplete - Failed to set to true."); } else { if (!qTD.InterruptOnComplete) { DBGERR(testName, "InterruptOnComplete - Failed to read as true."); } else { pqTD[0x09u] = 0xFF; qTD.InterruptOnComplete = false; if ((pqTD[0x09u] & 0x80u) != 0) { DBGERR(testName, "InterruptOnComplete - Failed to set to false."); } else { if (qTD.InterruptOnComplete) { DBGERR(testName, "InterruptOnComplete - Failed to read as false."); } } } } qTD.NextqTDPointer = (EHCI_qTD_Struct *)0xF2610369; //Read back should be 0xF2610360 if ((pqTD[0x00u] & 0xE0u) != 0x60u || pqTD[0x01u] != 0x03u || pqTD[0x02u] != 0x61u || pqTD[0x03u] != 0xF2u) { DBGERR(testName, "NextqTDPointer - Failed to set."); } else { if ((uint)qTD.NextqTDPointer != 0xF2610360u) { DBGERR(testName, "NextqTDPointer - Failed to read."); } } qTD.NextqTDPointerTerminate = true; if ((pqTD[0x00u] & 0x01u) == 0) { DBGERR(testName, "NextqTDPointerTerminate - Failed to set to true."); } else { if (!qTD.NextqTDPointerTerminate) { DBGERR(testName, "NextqTDPointerTerminate - Failed to read as true."); } else { pqTD[0x00u] = 0xFF; qTD.NextqTDPointerTerminate = false; if ((pqTD[0x00u] & 0x01u) != 0) { DBGERR(testName, "NextqTDPointerTerminate - Failed to set to false."); } else { if (qTD.NextqTDPointerTerminate) { DBGERR(testName, "NextqTDPointerTerminate - Failed to read as false."); } } } } qTD.PIDCode = 0xFF; //Shift! if ((pqTD[0x09u] & 0x03u) != 0x03u) { DBGERR(testName, "PIDCode - Failed to set."); } else { if ((uint)qTD.PIDCode != 0x03u) { DBGERR(testName, "PIDCode - Failed to read."); } } qTD.Status = 0xFF; //Shift! if (pqTD[0x08u] != 0xFFu) { DBGERR(testName, "Status - Failed to set."); } else { if ((uint)qTD.Status != 0xFFu) { DBGERR(testName, "Status - Failed to read."); } } qTD.TotalBytesToTransfer = 0xFFFF; //Read back should be 0x7FFF if (pqTD[0x0Au] != 0xFFu || (pqTD[0x0Bu] & 0x7Fu) != 0x7Fu) { DBGERR(testName, "TotalBytesToTransfer - Failed to set."); } else { if ((uint)qTD.TotalBytesToTransfer != 0x7FFFu) { DBGERR(testName, "TotalBytesToTransfer - Failed to read."); } } } catch { errors++; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); BasicConsole.SetTextColour(BasicConsole.default_colour); } finally { qTD.Free(); } if (errors > 0) { DBGERR(testName, ((FOS_System.String) "Test failed! Errors: ") + errors + " Warnings: " + warnings); } else { if (warnings > 0) { DBGWRN(testName, ((FOS_System.String) "Test passed with warnings: ") + warnings); } else { DBGMSG(testName, "Test passed."); } } DBGMSG(testName, "END"); BasicConsole.DelayOutput(1); }
public static void Test_QueueHeadWrapper() { FOS_System.String testName = "Queue Head Wrapper"; DBGMSG(testName, "START"); errors = 0; warnings = 0; EHCI_QueueHead qh = new EHCI_QueueHead(); try { byte *pQH = (byte *)qh.queueHead; //Verifications done via two methods: // 1. Check value from pointer & manual shifting to confirm set properly // 2. Check value from "get" method to confirm reading properly // 3. For boolean types, also test & verify setting to false! qh.Active = true; if ((pQH[0x18u] & 0x80u) == 0) { DBGERR(testName, "Active - Failed to set to true."); } else { if (!qh.Active) { DBGERR(testName, "Active - Failed to read as true."); } else { pQH[0x18u] = 0xFF; qh.Active = false; if ((pQH[0x18u] & 0x80u) != 0) { DBGERR(testName, "Active - Failed to set to false."); } else { if (qh.Active) { DBGERR(testName, "Active - Failed to read as false."); } } } } qh.ControlEndpointFlag = true; if ((pQH[0x07u] & 0x08u) == 0) { DBGERR(testName, "ControlEndpointFlag - Failed to set to true."); } else { if (!qh.ControlEndpointFlag) { DBGERR(testName, "ControlEndpointFlag - Failed to read as true."); } else { pQH[0x07u] = 0xFF; qh.ControlEndpointFlag = false; if ((pQH[0x07u] & 0x08u) != 0) { DBGERR(testName, "ControlEndpointFlag - Failed to set to false."); } else { if (qh.ControlEndpointFlag) { DBGERR(testName, "ControlEndpointFlag - Failed to read as false."); } } } } qh.CurrentqTDPointer = (EHCI_qTD_Struct *)0xDEADBEFFu; //- Read back should equal 0xDEADBEE0 if ((pQH[0x0Cu] & 0xF0u) != 0xF0u || pQH[0x0Du] != 0xBEu || pQH[0x0Eu] != 0xADu || pQH[0x0Fu] != 0xDEu) { DBGERR(testName, "CurrentqTDPointer - Failed to set."); } else { if ((uint)qh.CurrentqTDPointer != 0xDEADBEF0u) { DBGERR(testName, "CurrentqTDPointer - Failed to read."); } } qh.DataToggleControl = true; if ((pQH[0x05u] & 0x40u) == 0) { DBGERR(testName, "DataToggleControl - Failed to set to true."); } else { if (!qh.DataToggleControl) { DBGERR(testName, "DataToggleControl - Failed to read as true."); } else { pQH[0x05u] = 0xFF; qh.DataToggleControl = false; if ((pQH[0x05u] & 0x40u) != 0) { DBGERR(testName, "DataToggleControl - Failed to set to false."); } else { if (qh.DataToggleControl) { DBGERR(testName, "DataToggleControl - Failed to read as false."); } } } } qh.DeviceAddress = 0xDE; if ((pQH[0x04u] & 0x7Fu) != 0x5Eu) { DBGERR(testName, "DeviceAddress - Failed to set."); } else { if ((uint)qh.DeviceAddress != 0x5Eu) { DBGERR(testName, "DeviceAddress - Failed to read."); } } qh.EndpointNumber = 0xBF; //Shift! if ((pQH[0x05u] & 0x0Fu) != 0x0Fu) { DBGERR(testName, "EndpointNumber - Failed to set."); } else { if ((uint)qh.EndpointNumber != 0x0Fu) { DBGERR(testName, "EndpointNumber - Failed to read."); } } qh.EndpointSpeed = 0xB3; //Shift! if ((pQH[0x05u] & 0x30u) != 0x30u) { DBGERR(testName, "EndpointSpeed - Failed to set."); } else { if ((uint)qh.EndpointSpeed != 0x03u) { DBGERR(testName, "EndpointSpeed - Failed to read."); } } qh.HeadOfReclamationList = true; if ((pQH[0x05u] & 0x80u) == 0) { DBGERR(testName, "HeadOfReclamationList - Failed to set to true."); } else { if (!qh.HeadOfReclamationList) { DBGERR(testName, "HeadOfReclamationList - Failed to read as true."); } else { pQH[0x05u] = 0xFF; qh.HeadOfReclamationList = false; if ((pQH[0x05u] & 0x80u) != 0) { DBGERR(testName, "HeadOfReclamationList - Failed to set to false."); } else { if (qh.HeadOfReclamationList) { DBGERR(testName, "HeadOfReclamationList - Failed to read as false."); } } } } qh.HighBandwidthPipeMultiplier = 0xDF; //Shift! if ((pQH[0x0Bu] & 0xC0u) != 0xC0u) { DBGERR(testName, "HighBandwidthPipeMultiplier - Failed to set."); } else { if ((uint)qh.HighBandwidthPipeMultiplier != 0x03u) { DBGERR(testName, "HighBandwidthPipeMultiplier - Failed to read."); } } qh.HorizontalLinkPointer = (EHCI_QueueHead_Struct *)0xDEADBEFE; if ((pQH[0x00u] & 0xE0u) != 0xE0u || pQH[0x01u] != 0xBEu || pQH[0x02u] != 0xADu || pQH[0x03u] != 0xDEu) { DBGERR(testName, "HorizontalLinkPointer - Failed to set."); } else { if ((uint)qh.HorizontalLinkPointer != 0xDEADBEE0u) { DBGERR(testName, "HorizontalLinkPointer - Failed to read."); } } qh.HubAddr = 0xBE; //Shift! if ((pQH[0x0Au] & 0x7Fu) != 0x3Eu) { DBGERR(testName, "HubAddr - Failed to set."); } else { if ((uint)qh.HubAddr != 0x3Eu) { DBGERR(testName, "HubAddr - Failed to read."); } } qh.InactiveOnNextTransaction = true; if ((pQH[0x04u] & 0x80u) == 0) { DBGERR(testName, "InactiveOnNextTransaction - Failed to set to true."); } else { if (!qh.InactiveOnNextTransaction) { DBGERR(testName, "InactiveOnNextTransaction - Failed to read as true."); } else { pQH[0x04u] = 0xFF; qh.InactiveOnNextTransaction = false; if ((pQH[0x04u] & 0x80u) != 0) { DBGERR(testName, "InactiveOnNextTransaction - Failed to set to false."); } else { if (qh.InactiveOnNextTransaction) { DBGERR(testName, "InactiveOnNextTransaction - Failed to read as false."); } } } } qh.InterruptScheduleMask = 0xFE; //Shift! if (pQH[0x08u] != 0xFEu) { DBGERR(testName, "InterruptScheduleMask - Failed to set."); } else { if ((uint)qh.InterruptScheduleMask != 0xFEu) { DBGERR(testName, "InterruptScheduleMask - Failed to read."); } } qh.MaximumPacketLength = 0xDEAD; //Shift! if (pQH[0x06u] != 0xADu || (pQH[0x07u] & 0x07u) != 0x06u) { DBGERR(testName, "MaximumPacketLength - Failed to set."); } else { if ((uint)qh.MaximumPacketLength != 0x06ADu) { DBGERR(testName, "MaximumPacketLength - Failed to read."); } } qh.NakCountReload = 0xFF; //Shift! if ((pQH[0x07u] & 0xF0u) != 0xF0u) { DBGERR(testName, "NakCountReload - Failed to set."); } else { if ((uint)qh.NakCountReload != 0x0Fu) { DBGERR(testName, "NakCountReload - Failed to read."); } } qh.NextqTDPointer = (EHCI_qTD_Struct *)0xDEADBEFF; //- Read back should equal 0xDEADBEE0 if ((pQH[0x10u] & 0xF0u) != 0xF0u || pQH[0x11u] != 0xBEu || pQH[0x12u] != 0xADu || pQH[0x13u] != 0xDEu) { DBGERR(testName, "NextqTDPointer - Failed to set."); } else { if ((uint)qh.NextqTDPointer != 0xDEADBEF0u) { DBGERR(testName, "NextqTDPointer - Failed to read."); } } qh.NextqTDPointerTerminate = true; if ((pQH[0x10u] & 0x01u) == 0) { DBGERR(testName, "NextqTDPointerTerminate - Failed to set to true."); } else { if (!qh.NextqTDPointerTerminate) { DBGERR(testName, "NextqTDPointerTerminate - Failed to read as true."); } else { pQH[0x10u] = 0xFF; qh.NextqTDPointerTerminate = false; if ((pQH[0x10u] & 0x01u) != 0) { DBGERR(testName, "NextqTDPointerTerminate - Failed to set to false."); } else { if (qh.NextqTDPointerTerminate) { DBGERR(testName, "NextqTDPointerTerminate - Failed to read as false."); } } } } qh.PortNumber = 0xFF; //Shift! if ((pQH[0x0Au] & 0x80u) != 0x80u || (pQH[0x0Bu] & 0x3Fu) != 0x3Fu) { DBGERR(testName, "PortNumber - Failed to set."); } else { if ((uint)qh.PortNumber != 0x7Fu) { DBGERR(testName, "PortNumber - Failed to read."); } } qh.SplitCompletionMask = 0xBE; //Shift! if (pQH[0x09u] != 0xBEu) { DBGERR(testName, "SplitCompletionMask - Failed to set."); } else { if ((uint)qh.SplitCompletionMask != 0xBEu) { DBGERR(testName, "SplitCompletionMask - Failed to read."); } } qh.Terminate = true; if ((pQH[0x00u] & 0x01u) == 0) { DBGERR(testName, "Terminate - Failed to set to true."); } else { if (!qh.Terminate) { DBGERR(testName, "Terminate - Failed to read as true."); } else { pQH[0x00u] = 0xFF; qh.Terminate = false; if ((pQH[0x00u] & 0x01u) != 0) { DBGERR(testName, "Terminate - Failed to set to false."); } else { if (qh.Terminate) { DBGERR(testName, "Terminate - Failed to read as false."); } } } } qh.Type = 0xFF; //Shift! if ((pQH[0x00u] & 0x06u) != 0x06u) { DBGERR(testName, "Type - Failed to set."); } else { if ((uint)qh.Type != 0x03u) { DBGERR(testName, "Type - Failed to read."); } } } catch { errors++; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); BasicConsole.SetTextColour(BasicConsole.default_colour); } finally { qh.Free(); } if (errors > 0) { DBGERR(testName, ((FOS_System.String) "Test failed! Errors: ") + errors + " Warnings: " + warnings); } else { if (warnings > 0) { DBGWRN(testName, ((FOS_System.String) "Test passed with warnings: ") + warnings); } else { DBGMSG(testName, "Test passed."); } } DBGMSG(testName, "END"); BasicConsole.DelayOutput(1); }
public static void Test_PointerManipulation() { FOS_System.String testName = "Ptr Manipulation"; DBGMSG(testName, "START"); errors = 0; warnings = 0; byte *rootPtr = (byte *)FOS_System.Heap.Alloc(4096, 32); try { DBGMSG(testName, ((FOS_System.String) "rootPtr: ") + (uint)rootPtr); if (!Validate_PointerBoundaryAlignment(rootPtr, 32)) { DBGERR(testName, "Pointer not aligned on boundary correctly!"); } byte *retPtr = ReturnPointer(rootPtr); if (retPtr != rootPtr) { DBGERR(testName, "Passing and returning pointer via method failed."); } byte *shiftedPtr = (byte *)((uint *)rootPtr + 1); if (((uint)shiftedPtr) != ((uint)rootPtr) + 4) { DBGERR(testName, ((FOS_System.String) "Shifted pointer not shifted correctly! shiftedPtr: ") + (uint)shiftedPtr); } EHCITestingObject testObj = new EHCITestingObject(); testObj.ptr1 = rootPtr; testObj.ptr2 = (uint *)rootPtr; testObj.ptr3 = (ulong *)rootPtr; testObj.ptr4 = rootPtr; if (testObj.ptr1 != rootPtr) { DBGERR(testName, ((FOS_System.String) "Storing test pointer 1 failed! testObj.ptr1: ") + (uint)testObj.ptr1); } if (testObj.ptr2 != rootPtr) { DBGERR(testName, ((FOS_System.String) "Storing test pointer 2 failed! testObj.ptr2: ") + (uint)testObj.ptr2); } if (testObj.ptr3 != rootPtr) { DBGERR(testName, ((FOS_System.String) "Storing test pointer 3 failed! testObj.ptr3: ") + (uint)testObj.ptr3); } if (testObj.ptr4 != rootPtr) { DBGERR(testName, ((FOS_System.String) "Storing test pointer 4 failed! testObj.ptr4: ") + (uint)testObj.ptr4); } } catch { errors++; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); BasicConsole.SetTextColour(BasicConsole.default_colour); } finally { FOS_System.Heap.Free(rootPtr); } if (errors > 0) { DBGERR(testName, ((FOS_System.String) "Test failed! Errors: ") + errors + " Warnings: " + warnings); } else { if (warnings > 0) { DBGWRN(testName, ((FOS_System.String) "Test passed with warnings: ") + warnings); } else { DBGMSG(testName, "Test passed."); } } DBGMSG(testName, "END"); BasicConsole.DelayOutput(1); }
public static void Test_StructValueSetting() { FOS_System.String testName = "Strct Value Setting"; DBGMSG(testName, "START"); errors = 0; warnings = 0; uint structSize = (uint)sizeof(EHCITestingStruct); if (structSize != 8 * 4) { DBGERR(testName, ((FOS_System.String) "Struct size incorrect! structSize: ") + structSize); } if (errors == 0) { EHCITestingStruct *rootPtr = (EHCITestingStruct *)FOS_System.Heap.Alloc(structSize); byte *bRootPtr = (byte *)rootPtr; try { DBGMSG(testName, ((FOS_System.String) "rootPtr: ") + (uint)rootPtr); rootPtr->u1 = 0xDEADBEEF; if (rootPtr->u1 != 0xDEADBEEF || bRootPtr[0] != 0xEF || bRootPtr[1] != 0xBE || bRootPtr[2] != 0xAD || bRootPtr[3] != 0xDE) { DBGERR(testName, "Getting/setting struct u1 failed!"); } rootPtr->u2 = 0x12345678; if (rootPtr->u1 != 0xDEADBEEF || bRootPtr[0] != 0xEF || bRootPtr[1] != 0xBE || bRootPtr[2] != 0xAD || bRootPtr[3] != 0xDE) { DBGERR(testName, "Getting/setting struct u2 failed! Affected u1 value."); } if (rootPtr->u2 != 0x12345678 || bRootPtr[4] != 0x78 || bRootPtr[5] != 0x56 || bRootPtr[6] != 0x34 || bRootPtr[7] != 0x12) { DBGERR(testName, "Getting/setting struct u2 failed!"); } rootPtr->u3 = 0xBEEFDEAD; if (rootPtr->u1 != 0xDEADBEEF || bRootPtr[0] != 0xEF || bRootPtr[1] != 0xBE || bRootPtr[2] != 0xAD || bRootPtr[3] != 0xDE) { DBGERR(testName, "Getting/setting struct u3 failed! Affected u1 value."); } if (rootPtr->u2 != 0x12345678 || bRootPtr[4] != 0x78 || bRootPtr[5] != 0x56 || bRootPtr[6] != 0x34 || bRootPtr[7] != 0x12) { DBGERR(testName, "Getting/setting struct u3 failed! Affected u2 value."); } if (rootPtr->u3 != 0xBEEFDEAD || bRootPtr[8] != 0xAD || bRootPtr[9] != 0xDE || bRootPtr[10] != 0xEF || bRootPtr[11] != 0xBE) { DBGERR(testName, "Getting/setting struct u3 failed!"); } rootPtr->u4 = 0x09876543; if (rootPtr->u1 != 0xDEADBEEF || bRootPtr[0] != 0xEF || bRootPtr[1] != 0xBE || bRootPtr[2] != 0xAD || bRootPtr[3] != 0xDE) { DBGERR(testName, "Getting/setting struct u4 failed! Affected u1 value."); } if (rootPtr->u2 != 0x12345678 || bRootPtr[4] != 0x78 || bRootPtr[5] != 0x56 || bRootPtr[6] != 0x34 || bRootPtr[7] != 0x12) { DBGERR(testName, "Getting/setting struct u4 failed! Affected u2 value."); } if (rootPtr->u3 != 0xBEEFDEAD || bRootPtr[8] != 0xAD || bRootPtr[9] != 0xDE || bRootPtr[10] != 0xEF || bRootPtr[11] != 0xBE) { DBGERR(testName, "Getting/setting struct u4 failed! Affected u3 value."); } if (rootPtr->u4 != 0x09876543 || bRootPtr[12] != 0x43 || bRootPtr[13] != 0x65 || bRootPtr[14] != 0x87 || bRootPtr[15] != 0x09) { DBGERR(testName, "Getting/setting struct u4 failed!"); } Test_StructValueSettingAsArg("Strct Val Set by val", *rootPtr); Test_StructValueSettingAsArg("Strct Val Set by ptr", rootPtr, bRootPtr); } catch { errors++; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); BasicConsole.SetTextColour(BasicConsole.default_colour); } finally { FOS_System.Heap.Free(rootPtr); } } if (errors > 0) { DBGERR(testName, ((FOS_System.String) "Test failed! Errors: ") + errors + " Warnings: " + warnings); } else { if (warnings > 0) { DBGWRN(testName, ((FOS_System.String) "Test passed with warnings: ") + warnings); } else { DBGMSG(testName, "Test passed."); } } DBGMSG(testName, "END"); BasicConsole.DelayOutput(1); }
public static void *NewObj(FOS_System.Type theType) { if (!Enabled) { BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("Warning! GC returning null pointer because GC not enabled."); BasicConsole.Write("Last disabler: "); BasicConsole.WriteLine(lastDisabler); BasicConsole.DelayOutput(10); BasicConsole.SetTextColour(BasicConsole.default_colour); return(null); } #if GC_TRACE if (OutputTrace) { BasicConsole.WriteLine("NewObj"); } #endif EnterCritical("NewObj"); try { InsideGC = true; //Alloc space for GC header that prefixes object data //Alloc space for new object uint totalSize = theType.Size; totalSize += (uint)sizeof(GCHeader); GCHeader *newObjPtr = (GCHeader *)Heap.AllocZeroed(totalSize, "GC : NewObject"); if ((UInt32)newObjPtr == 0) { InsideGC = false; BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't create a new object because the heap returned a null pointer."); BasicConsole.DelayOutput(10); BasicConsole.SetTextColour(BasicConsole.default_colour); return(null); } NumObjs++; //Initialise the GCHeader SetSignature(newObjPtr); newObjPtr->RefCount = 1; //Initialise the object _Type field FOS_System.ObjectWithType newObj = (FOS_System.ObjectWithType)Utilities.ObjectUtilities.GetObject(newObjPtr + 1); newObj._Type = theType; //Move past GCHeader byte *newObjBytePtr = (byte *)(newObjPtr + 1); InsideGC = false; return(newObjBytePtr); } finally { ExitCritical(); } }
public static void Main() { BasicConsole.WriteLine("Kernel task! "); BasicConsole.WriteLine(" > Executing normally..."); #region Dictionary Test /*try * { * UInt32Dictionary dic = new UInt32Dictionary(); * * for (uint i = 0; i < 9; i += 3) * { * BasicConsole.WriteLine("Dictionary test loop"); * BasicConsole.WriteLine("--------------------"); * * uint key1 = 0xC0DEC0DEu + (0x100u * i); * uint key2 = 0xC0DEC0DEu + (0x100u * (i+1)); * uint key3 = 0xC0DEC0DEu + (0x100u * (i+2)); * * uint value1 = 0xDEADBEE0u + (0x1u * i); * uint value2 = 0xDEADBEE0u + (0x1u * (i+1)); * uint value3 = 0xDEADBEE0u + (0x1u * (i+2)); * * dic.Add(key1, value1); * dic.Add(key2, value2); * dic.Add(key3, value3); * * for(uint j = 50 * i; j < (50 * (i+1))-20; j++) * { * dic.Add(j, j); * } * * if (!dic.Contains(key1)) * { * BasicConsole.WriteLine("Dictionary doesn't contain key 1."); * } * else if (dic[key1] != value1) * { * BasicConsole.WriteLine("Dictionary value for key 1 wrong."); * } * else * { * BasicConsole.WriteLine("Okay (1)"); * } * if (!dic.Contains(key2)) * { * BasicConsole.WriteLine("Dictionary doesn't contain key1"); * } * else if (dic[key2] != value2) * { * BasicConsole.WriteLine("Dictionary value for key1 wrong."); * } * else * { * BasicConsole.WriteLine("Okay (2)"); * } * if (!dic.Contains(key3)) * { * BasicConsole.WriteLine("Dictionary doesn't contain key1"); * } * else if (dic[key3] != value3) * { * BasicConsole.WriteLine("Dictionary value for key1 wrong."); * } * else * { * BasicConsole.WriteLine("Okay (3)"); * } * * dic.Remove(key1); * * if (dic.Contains(key1)) * { * BasicConsole.WriteLine("Dictionary contains key1!"); * } * else * { * BasicConsole.WriteLine("Okay (4)"); * } * * BasicConsole.WriteLine("Iterating"); * UInt32Dictionary.Iterator itr = dic.GetIterator(); * while (itr.HasNext()) * { * UInt32Dictionary.KeyValuePair pair = itr.Next(); * BasicConsole.WriteLine("Pair: key=" + (FOS_System.String)pair.Key + ", value=" + pair.Value); * } * * dic.Remove(key2); * * for (uint j = (50 * i)+30; j < (50 * (i + 1)); j++) * { * dic.Add(j, j); * } * * if (dic.Contains(key2)) * { * BasicConsole.WriteLine("Dictionary contains key2!"); * } * else * { * BasicConsole.WriteLine("Okay (5)"); * } * * * dic.Remove(key3); * * if (dic.Contains(key3)) * { * BasicConsole.WriteLine("Dictionary contains key3!"); * } * else * { * BasicConsole.WriteLine("Okay (6)"); * } * * itr = dic.GetIterator(); * while (itr.HasNext()) * { * UInt32Dictionary.KeyValuePair pair = itr.Next(); * BasicConsole.WriteLine("Pair: key=" + (FOS_System.String)pair.Key + ", value=" + pair.Value); * } * } * } * catch * { * BasicConsole.WriteLine("Error testing UInt32Dictionary."); * BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); * } * BasicConsole.DelayOutput(5); */ #endregion DeferredSyscallsInfo_Unqueued = new Queue(256, false); DeferredSyscallsInfo_Queued = new Queue(DeferredSyscallsInfo_Unqueued.Capacity, false); for (int i = 0; i < DeferredSyscallsInfo_Unqueued.Capacity; i++) { DeferredSyscallsInfo_Unqueued.Push(new DeferredSyscallInfo()); } try { BasicConsole.WriteLine(" > Initialising system calls..."); ProcessManager.CurrentProcess.SyscallHandler = SyscallHandler; ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterSyscallHandler); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.DeregisterSyscallHandler); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.StartThread); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SleepThread); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WakeThread); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterPipeOutpoint); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetNumPipeOutpoints); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetPipeOutpoints); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WaitOnPipeCreate); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReadPipe); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WritePipe); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SendMessage); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReceiveMessage); //ProcessManager.CurrentProcess.OutputMemTrace = true; BasicConsole.WriteLine(" > Starting Idle process..."); Process IdleProcess = ProcessManager.CreateProcess(Tasks.IdleTask.Main, "Idle", false, true); ProcessManager.RegisterProcess(IdleProcess, Scheduler.Priority.ZeroTimed); BasicConsole.WriteLine(" > Starting deferred syscalls thread..."); DeferredSyscallsThread = ProcessManager.CurrentProcess.CreateThread(DeferredSyscallsThread_Main, "Deferred Sys Calls"); #if DEBUG BasicConsole.WriteLine(" > Starting Debugger thread..."); Debug.Debugger.MainThread = ProcessManager.CurrentProcess.CreateThread(Debug.Debugger.Main, "Debugger"); #endif BasicConsole.WriteLine(" > Starting GC Cleanup thread..."); ProcessManager.CurrentProcess.CreateThread(Tasks.GCCleanupTask.Main, "GC Cleanup"); BasicConsole.WriteLine(" > Starting Window Manager..."); Process WindowManagerProcess = ProcessManager.CreateProcess(WindowManagerTask.Main, "Window Manager", false, true); WindowManagerTask_ProcessId = WindowManagerProcess.Id; //WindowManagerProcess.OutputMemTrace = true; ProcessManager.RegisterProcess(WindowManagerProcess, Scheduler.Priority.Normal); BasicConsole.WriteLine(" > Waiting for Window Manager to be ready..."); while (!WindowManagerTask.Ready) { BasicConsole.WriteLine(" > [Wait pause]"); SystemCalls.SleepThread(1000); } BasicConsole.WriteLine(" > Window Manager reported ready."); BasicConsole.WriteLine(" > Starting Device Manager..."); Process DeviceManagerProcess = ProcessManager.CreateProcess(DeviceManagerTask.Main, "Device Manager", false, true); //DeviceManagerProcess.OutputMemTrace = true; ProcessManager.RegisterProcess(DeviceManagerProcess, Scheduler.Priority.Normal); //TODO: Main task for commands etc BasicConsole.WriteLine("Started."); BasicConsole.PrimaryOutputEnabled = false; //BasicConsole.SecondaryOutputEnabled = false; try { BasicConsole.WriteLine("KT > Creating virtual keyboard..."); keyboard = new Hardware.Keyboards.VirtualKeyboard(); BasicConsole.WriteLine("KT > Creating virtual console..."); console = new Consoles.VirtualConsole(); BasicConsole.WriteLine("KT > Connecting virtual console..."); console.Connect(); BasicConsole.WriteLine("KT > Creating main shell..."); Shells.MainShell shell = new Shells.MainShell(console, keyboard); BasicConsole.WriteLine("KT > Running..."); uint loops = 0; while (!Terminating) { try { //FOS_System.String msg = "KT > Hello, world! (" + (FOS_System.String)loops++ + ")"; //console.WriteLine(msg); //BasicConsole.WriteLine(msg); //SystemCalls.SleepThread(1000); shell.Execute(); } catch { BasicConsole.WriteLine("KT > Error executing MainShell!"); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); } } } catch { BasicConsole.WriteLine("KT > Error initialising!"); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); } //BasicConsole.WriteLine(" > Starting Play Notes task..."); //ProcessManager.CurrentProcess.CreateThread(Hardware.Tasks.PlayNotesTask.Main); //Console.InitDefault(); //Shell.InitDefault(); //BasicConsole.PrimaryOutputEnabled = false; //Shell.Default.Execute(); //BasicConsole.PrimaryOutputEnabled = true; //if (!Shell.Default.Terminating) //{ // Console.Default.WarningColour(); // Console.Default.WriteLine("Abnormal shell shutdown!"); // Console.Default.DefaultColour(); //} //else //{ // Console.Default.Clear(); //} } catch { BasicConsole.PrimaryOutputEnabled = true; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); BasicConsole.SetTextColour(BasicConsole.default_colour); } BasicConsole.WriteLine(); BasicConsole.WriteLine("---------------------"); BasicConsole.WriteLine(); BasicConsole.WriteLine("End of kernel task."); ExceptionMethods.HaltReason = "Managed main thread ended."; //TODO: Exit syscall }
public static void Main() { BasicConsole.WriteLine("Kernel task! "); BasicConsole.WriteLine(" > Executing normally..."); try { PriorityQueue queue = new PriorityQueue(20); TestComparable toRemove = new TestComparable(2); queue.Insert(new TestComparable(20)); queue.Insert(new TestComparable(19)); queue.Insert(new TestComparable(18)); queue.Insert(new TestComparable(17)); queue.Insert(new TestComparable(16)); queue.Insert(new TestComparable(15)); queue.Insert(new TestComparable(5)); queue.Insert(new TestComparable(4)); queue.Insert(new TestComparable(3)); queue.Insert(toRemove); queue.Insert(new TestComparable(2)); queue.Insert(new TestComparable(1)); BasicConsole.WriteLine(queue.ToString()); queue.Delete(toRemove); BasicConsole.WriteLine(queue.ToString()); TestComparable minNode = (TestComparable)queue.ExtractMin(); while (minNode != null) { BasicConsole.WriteLine(minNode.Key); minNode = (TestComparable)queue.ExtractMin(); } } catch { BasicConsole.WriteLine("Error!"); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); } //BasicConsole.DelayOutput(100); DeferredSyscallsInfo_Unqueued = new Queue(256, false); DeferredSyscallsInfo_Queued = new Queue(DeferredSyscallsInfo_Unqueued.Capacity, false); for (int i = 0; i < DeferredSyscallsInfo_Unqueued.Capacity; i++) { DeferredSyscallsInfo_Unqueued.Push(new DeferredSyscallInfo()); } try { BasicConsole.WriteLine(" > Initialising system calls..."); ProcessManager.CurrentProcess.SyscallHandler = SyscallHandler; ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterSyscallHandler); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.DeregisterSyscallHandler); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.StartThread); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SleepThread); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WakeThread); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.RegisterPipeOutpoint); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetNumPipeOutpoints); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.GetPipeOutpoints); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WaitOnPipeCreate); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReadPipe); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.WritePipe); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.SendMessage); ProcessManager.CurrentProcess.SyscallsToHandle.Set((int)SystemCallNumbers.ReceiveMessage); //ProcessManager.CurrentProcess.OutputMemTrace = true; //BasicConsole.WriteLine(" > Starting deferred syscalls thread..."); //DeferredSyscallsThread = ProcessManager.CurrentProcess.CreateThread(DeferredSyscallsThread_Main, "Deferred Sys Calls"); //BasicConsole.WriteLine(" > Starting GC Cleanup thread..."); //ProcessManager.CurrentProcess.CreateThread(Tasks.GCCleanupTask.Main, "GC Cleanup"); BasicConsole.WriteLine(" > Starting Idle thread..."); ProcessManager.CurrentProcess.CreateThread(Tasks.IdleTask.Main, "Idle"); #if DEBUG BasicConsole.WriteLine(" > Starting Debugger thread..."); Debug.Debugger.MainThread = ProcessManager.CurrentProcess.CreateThread(Debug.Debugger.Main, "Debugger"); #endif bool OK = true; while (OK) { ; } BasicConsole.WriteLine(" > Starting Window Manager..."); Process WindowManagerProcess = ProcessManager.CreateProcess(WindowManagerTask.Main, "Window Manager", false, true); WindowManagerTask_ProcessId = WindowManagerProcess.Id; //WindowManagerProcess.OutputMemTrace = true; ProcessManager.RegisterProcess(WindowManagerProcess, Scheduler.Priority.Normal); BasicConsole.WriteLine(" > Waiting for Window Manager to be ready..."); while (!WindowManagerTask.Ready) { BasicConsole.WriteLine(" > [Wait pause]"); Thread.Sleep(1000); } BasicConsole.WriteLine(" > Window Manager reported ready."); BasicConsole.WriteLine(" > Starting Device Manager..."); Process DeviceManagerProcess = ProcessManager.CreateProcess(DeviceManagerTask.Main, "Device Manager", false, true); //DeviceManagerProcess.OutputMemTrace = true; ProcessManager.RegisterProcess(DeviceManagerProcess, Scheduler.Priority.Normal); //TODO: Main task for commands etc BasicConsole.WriteLine("Started."); BasicConsole.PrimaryOutputEnabled = false; //BasicConsole.SecondaryOutputEnabled = false; try { BasicConsole.WriteLine("KT > Creating virtual keyboard..."); keyboard = new Hardware.Keyboards.VirtualKeyboard(); BasicConsole.WriteLine("KT > Creating virtual console..."); console = new Consoles.VirtualConsole(); BasicConsole.WriteLine("KT > Connecting virtual console..."); console.Connect(); BasicConsole.WriteLine("KT > Creating main shell..."); Shells.MainShell shell = new Shells.MainShell(console, keyboard); BasicConsole.WriteLine("KT > Running..."); //uint loops = 0; while (!Terminating) { try { shell.Execute(); } catch { BasicConsole.WriteLine("KT > Error executing MainShell!"); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); } } } catch { BasicConsole.WriteLine("KT > Error initialising!"); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); } //BasicConsole.WriteLine(" > Starting Play Notes task..."); //ProcessManager.CurrentProcess.CreateThread(Hardware.Tasks.PlayNotesTask.Main); //Console.InitDefault(); //Shell.InitDefault(); //BasicConsole.PrimaryOutputEnabled = false; //Shell.Default.Execute(); //BasicConsole.PrimaryOutputEnabled = true; //if (!Shell.Default.Terminating) //{ // Console.Default.WarningColour(); // Console.Default.WriteLine("Abnormal shell shutdown!"); // Console.Default.DefaultColour(); //} //else //{ // Console.Default.Clear(); //} } catch { BasicConsole.PrimaryOutputEnabled = true; BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(ExceptionMethods.CurrentException.Message); BasicConsole.SetTextColour(BasicConsole.default_colour); } BasicConsole.WriteLine(); BasicConsole.WriteLine("---------------------"); BasicConsole.WriteLine(); BasicConsole.WriteLine("End of kernel task."); ExceptionMethods.HaltReason = "Managed main thread ended."; //TODO: Exit syscall }
public static void Main() { OwnerThread = ProcessManager.CurrentThread; Thread.Sleep_Indefinitely(); while (!Terminate) { //Scheduler.Disable(); Awake = false; //BasicConsole.WriteLine("Playing notes..."); while (LiveNoteRequests.Count > 0) { //BasicConsole.WriteLine("Playing note..."); NoteRequest theReq = (NoteRequest)LiveNoteRequests.Pop(); try { Hardware.Timers.PIT.MusicalNote note = theReq.note; Hardware.Timers.PIT.MusicalNoteValue duration = theReq.duration; int bpm = theReq.bpm; int dur_ms = (int)duration * 60 * 1000 / (bpm * 16); long do_ms = dur_ms; if (dur_ms >= 2000) { dur_ms -= 2000; do_ms = 2000; } else { dur_ms = 0; } NoteState state = new NoteState() { dur_ms = dur_ms }; if (note != Timers.PIT.MusicalNote.Silent) { Hardware.Timers.PIT.ThePIT.PlaySound((int)note); } Playing = true; state.handlerId = Hardware.Timers.PIT.ThePIT.RegisterHandler(new Hardware.Timers.PITHandler(SysCall_StopNoteHandler, state, 1000000L * do_ms, true)); while (Playing) { Thread.Sleep(50); } } catch { BasicConsole.Write("Error processing note request! "); if (ExceptionMethods.CurrentException != null) { BasicConsole.Write(ExceptionMethods.CurrentException.Message); } BasicConsole.WriteLine(); Playing = false; Hardware.Timers.PIT.ThePIT.MuteSound(); BasicConsole.DelayOutput(15); } finally { DeadNoteRequests.Push(theReq); } } //BasicConsole.WriteLine("Finished playing notes."); if (!Awake) { //BasicConsole.WriteLine("Sleeping non-critical interrupts thread..."); //Scheduler.Enable(); if (!Thread.Sleep_Indefinitely()) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Failed to sleep play notes thread!"); BasicConsole.SetTextColour(BasicConsole.default_colour); } } } }
public static void *NewArr(int length, FOS_System.Type elemType) { if (!Enabled) { BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("Warning! GC returning null pointer because GC not enabled."); BasicConsole.Write("Last disabler: "); BasicConsole.WriteLine(lastDisabler); BasicConsole.DelayOutput(10); BasicConsole.SetTextColour(BasicConsole.default_colour); return(null); } #if GC_TRACE if (OutputTrace) { BasicConsole.WriteLine("NewArr"); } #endif EnterCritical("NewArr"); try { if (length < 0) { ExceptionMethods.Throw_OverflowException(); } InsideGC = true; //Alloc space for GC header that prefixes object data //Alloc space for new array object //Alloc space for new array elems uint totalSize = ((FOS_System.Type) typeof(FOS_System.Array)).Size; if (elemType.IsValueType) { totalSize += elemType.Size * (uint)length; } else { totalSize += elemType.StackSize * (uint)length; } totalSize += (uint)sizeof(GCHeader); GCHeader *newObjPtr = (GCHeader *)Heap.AllocZeroed(totalSize, "GC : NewArray"); if ((UInt32)newObjPtr == 0) { InsideGC = false; BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't create a new array because the heap returned a null pointer."); BasicConsole.DelayOutput(10); BasicConsole.SetTextColour(BasicConsole.default_colour); return(null); } NumObjs++; //Initialise the GCHeader SetSignature(newObjPtr); newObjPtr->RefCount = 1; FOS_System.Array newArr = (FOS_System.Array)Utilities.ObjectUtilities.GetObject(newObjPtr + 1); newArr._Type = (FOS_System.Type) typeof(FOS_System.Array); newArr.length = length; newArr.elemType = elemType; //Move past GCHeader byte *newObjBytePtr = (byte *)(newObjPtr + 1); InsideGC = false; return(newObjBytePtr); } finally { ExitCritical(); } }
protected void InterruptHandler() { #if UHCI_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("UHCI: Interrupt handler"); BasicConsole.SetTextColour(BasicConsole.default_colour); BasicConsole.DelayOutput(20); #endif ushort val = USBSTS.Read_UInt16(); if (val == 0) // Interrupt came from another UHCI device { return; } //if ((val & UHCI_Consts.STS_USBINT) == 0) //{ // //printf("\nUSB UHCI %u: ", u->num); //} //textColor(IMPORTANT); #if UHCI_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); #endif if ((val & UHCI_Consts.STS_USBINT) != 0) { #if UHCI_TRACE BasicConsole.WriteLine(((FOS_System.String) "UHCI Frame: ") + FRNUM.Read_UInt16() + " - USB transaction completed"); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_USBINT); // reset interrupt TransactionsCompleted++; } if ((val & UHCI_Consts.STS_RESUME_DETECT) != 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Resume Detect"); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_RESUME_DETECT); // reset interrupt } #if UHCI_TRACE BasicConsole.SetTextColour(BasicConsole.error_colour); #endif if ((val & UHCI_Consts.STS_HCHALTED) != 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Host Controller Halted"); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_HCHALTED); // reset interrupt } if ((val & UHCI_Consts.STS_HC_PROCESS_ERROR) != 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Host Controller Process Error"); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_HC_PROCESS_ERROR); // reset interrupt } if ((val & UHCI_Consts.STS_USB_ERROR) != 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: USB Error"); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_USB_ERROR); // reset interrupt } if ((val & UHCI_Consts.STS_HOST_SYSTEM_ERROR) != 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Host System Error"); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_HOST_SYSTEM_ERROR); // reset interrupt } #if UHCI_TRACE BasicConsole.SetTextColour(BasicConsole.default_colour); #endif }
protected void ResetHC() { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: ResetHC"); BasicConsole.DelayOutput(5); #endif //Processes.Scheduler.Disable(); // http://www.lowlevel.eu/wiki/Universal_Host_Controller_Interface#Informationen_vom_PCI-Treiber_holen ushort legacySupport = pciDevice.ReadRegister16(UHCI_Consts.PCI_LEGACY_SUPPORT); pciDevice.WriteRegister16(UHCI_Consts.PCI_LEGACY_SUPPORT, UHCI_Consts.PCI_LEGACY_SUPPORT_STATUS); // resets support status bits in Legacy support register USBCMD.Write_UInt16(UHCI_Consts.CMD_GRESET); Hardware.Devices.Timer.Default.Wait(50); USBCMD.Write_UInt16(0); RootPortCount = (byte)(pciDevice.BaseAddresses[4].Size() / 2); #if UHCI_TRACE BasicConsole.WriteLine(((FOS_System.String) "UHCI: RootPortCount=") + RootPortCount); #endif for (byte i = 2; i < RootPortCount; i++) { if ((PORTSC1.Read_UInt16((ushort)(i * 2)) & UHCI_Consts.PORT_VALID) == 0 || (PORTSC1.Read_UInt16((ushort)(i * 2)) == 0xFFFF)) { RootPortCount = i; break; } } #if UHCI_TRACE BasicConsole.WriteLine(((FOS_System.String) "UHCI: RootPortCount=") + RootPortCount); #endif if (RootPortCount > UHCI_Consts.PORTMAX) { RootPortCount = UHCI_Consts.PORTMAX; } #if UHCI_TRACE BasicConsole.WriteLine(((FOS_System.String) "UHCI: RootPortCount=") + RootPortCount); BasicConsole.DelayOutput(1); #endif RootPorts.Empty(); for (byte i = 0; i < RootPortCount; i++) { RootPorts.Add(new HCPort() { portNum = i }); } #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Checking HC state: Get USBCMD..."); BasicConsole.DelayOutput(1); #endif ushort usbcmd = USBCMD.Read_UInt16(); #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Checking HC state: Check..."); BasicConsole.DelayOutput(1); #endif if ((legacySupport & ~(UHCI_Consts.PCI_LEGACY_SUPPORT_STATUS | UHCI_Consts.PCI_LEGACY_SUPPORT_NO_CHG | UHCI_Consts.PCI_LEGACY_SUPPORT_PIRQ)) != 0 || (usbcmd & UHCI_Consts.CMD_RS) != 0 || (usbcmd & UHCI_Consts.CMD_CF) != 0 || (usbcmd & UHCI_Consts.CMD_EGSM) == 0 || (USBINTR.Read_UInt16() & UHCI_Consts.INT_MASK) != 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Checking HC state: Do reset..."); BasicConsole.DelayOutput(1); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_MASK); Hardware.Devices.Timer.Default.Wait(1); USBCMD.Write_UInt16(UHCI_Consts.CMD_HCRESET); byte timeout = 50; while ((USBCMD.Read_UInt16() & UHCI_Consts.CMD_HCRESET) != 0) { if (timeout == 0) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: HC Reset timed out!"); BasicConsole.DelayOutput(1); #endif break; } Hardware.Devices.Timer.Default.Wait(10); timeout--; } #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Checking HC state: Turning off interrupts and HC..."); BasicConsole.DelayOutput(1); #endif USBINTR.Write_UInt16(0); // switch off all interrupts USBCMD.Write_UInt16(0); // switch off the host controller #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Checking HC state: Disabling ports..."); BasicConsole.DelayOutput(1); #endif for (byte i = 0; i < RootPortCount; i++) // switch off the valid root ports { PORTSC1.Write_UInt16(0, (ushort)(i * 2)); } } // TODO: mutex for frame list #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Creating queue head..."); BasicConsole.DelayOutput(1); #endif UHCI_QueueHead_Struct *qh = (UHCI_QueueHead_Struct *)FOS_System.Heap.AllocZeroedAPB((uint)sizeof(UHCI_QueueHead_Struct), 32, "UHCI : ResetHC"); qh->next = (UHCI_QueueHead_Struct *)UHCI_Consts.BIT_T; qh->transfer = (UHCI_qTD_Struct *)UHCI_Consts.BIT_T; qh->q_first = null; qh->q_last = null; qhPointer = qh; #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Setting up frame list entries..."); BasicConsole.DelayOutput(1); #endif for (ushort i = 0; i < 1024; i++) { FrameList[i] = UHCI_Consts.BIT_T; } #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Setting SOFMOD..."); BasicConsole.DelayOutput(1); #endif // define each millisecond one frame, provide physical address of frame list, and start at frame 0 SOFMOD.Write_Byte(0x40); // SOF cycle time: 12000. For a 12 MHz SOF counter clock input, this produces a 1 ms Frame period. #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Setting frame base addr and frame num..."); BasicConsole.DelayOutput(1); #endif FRBASEADD.Write_UInt32((uint)VirtMemManager.GetPhysicalAddress(FrameList)); FRNUM.Write_UInt16(0); #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Setting PCI PIRQ..."); BasicConsole.DelayOutput(1); #endif // set PIRQ pciDevice.WriteRegister16(UHCI_Consts.PCI_LEGACY_SUPPORT, UHCI_Consts.PCI_LEGACY_SUPPORT_PIRQ); #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Starting HC..."); BasicConsole.DelayOutput(1); #endif // start host controller and mark it configured with a 64-byte max packet USBSTS.Write_UInt16(UHCI_Consts.STS_MASK); USBINTR.Write_UInt16(UHCI_Consts.INT_MASK); // switch on all interrupts USBCMD.Write_UInt16((ushort)(UHCI_Consts.CMD_RS | UHCI_Consts.CMD_CF | UHCI_Consts.CMD_MAXP)); #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Reset CSC ports..."); BasicConsole.DelayOutput(1); #endif for (byte i = 0; i < RootPortCount; i++) // reset the CSC of the valid root ports { PORTSC1.Write_UInt16(UHCI_Consts.PORT_CS_CHANGE, (ushort)(i * 2)); } #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Forcing global resume..."); BasicConsole.DelayOutput(1); #endif USBSTS.Write_UInt16(UHCI_Consts.STS_MASK); #if UHCI_TRACE BasicConsole.WriteLine(" - STS MASK set"); #endif USBCMD.Write_UInt16((ushort)(UHCI_Consts.CMD_RS | UHCI_Consts.CMD_CF | UHCI_Consts.CMD_MAXP | UHCI_Consts.CMD_FGR)); #if UHCI_TRACE BasicConsole.WriteLine(" - FGR issued"); #endif Hardware.Devices.Timer.Default.Wait(20); USBCMD.Write_UInt16((ushort)(UHCI_Consts.CMD_RS | UHCI_Consts.CMD_CF | UHCI_Consts.CMD_MAXP)); #if UHCI_TRACE BasicConsole.WriteLine(" - FGR cleared"); BasicConsole.DelayOutput(1); #endif Hardware.Devices.Timer.Default.Wait(100); #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Getting run state..."); BasicConsole.DelayOutput(1); #endif run = (USBCMD.Read_UInt16() & UHCI_Consts.CMD_RS) != 0; if (!run) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("UHCI: Run/Stop not set!"); BasicConsole.SetTextColour(BasicConsole.default_colour); BasicConsole.DelayOutput(5); } else { if ((USBSTS.Read_UInt16() & UHCI_Consts.STS_HCHALTED) == 0) { Status = HCIStatus.Active; EnablePorts(); // attaches the ports } else { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("UHCI: HC Halted!"); BasicConsole.SetTextColour(BasicConsole.default_colour); BasicConsole.DelayOutput(5); } } }
public static void _DecrementRefCount(byte *objPtr) { if ((uint)objPtr < (uint)sizeof(GCHeader)) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't decrement ref count of an object in low memory."); BasicConsole.DelayOutput(5); BasicConsole.SetTextColour(BasicConsole.default_colour); } GCHeader *gcHeaderPtr = (GCHeader *)(objPtr - sizeof(GCHeader)); if (CheckSignature(gcHeaderPtr)) { gcHeaderPtr->RefCount--; //If the ref count goes below 0 then there was a circular reference somewhere. // In actuality we don't care we can just only do cleanup when the ref count is // exactly 0. if (gcHeaderPtr->RefCount == 0) { #if GC_TRACE if (OutputTrace) { BasicConsole.WriteLine("Cleaned up object."); } #endif FOS_System.Object obj = (FOS_System.Object)Utilities.ObjectUtilities.GetObject(objPtr); if (obj is FOS_System.Array) { //Decrement ref count of elements FOS_System.Array arr = (FOS_System.Array)obj; if (!arr.elemType.IsValueType) { FOS_System.Object[] objArr = (FOS_System.Object[])Utilities.ObjectUtilities.GetObject(objPtr); for (int i = 0; i < arr.length; i++) { DecrementRefCount(objArr[i], true); } } } //Cleanup fields FieldInfo *FieldInfoPtr = obj._Type.FieldTablePtr; //Loop through all fields. The if-block at the end handles moving to parent // fields. while (FieldInfoPtr != null) { if (FieldInfoPtr->Size > 0) { FOS_System.Type fieldType = (FOS_System.Type)Utilities.ObjectUtilities.GetObject(FieldInfoPtr->FieldType); if (!fieldType.IsValueType && !fieldType.IsPointer) { byte * fieldPtr = objPtr + FieldInfoPtr->Offset; FOS_System.Object theFieldObj = (FOS_System.Object)Utilities.ObjectUtilities.GetObject(fieldPtr); DecrementRefCount(theFieldObj, true); #if GC_TRACE if (OutputTrace) { BasicConsole.WriteLine("Cleaned up field."); } #endif } FieldInfoPtr++; } if (FieldInfoPtr->Size == 0) { FieldInfoPtr = (FieldInfo *)FieldInfoPtr->FieldType; } } AddObjectToCleanup(gcHeaderPtr, objPtr); } } }
public static void DBGWRN(FOS_System.String testName, FOS_System.String msg) { BasicConsole.SetTextColour(BasicConsole.warning_colour); DBGMSG(testName, msg); BasicConsole.SetTextColour(BasicConsole.default_colour); }
protected override void _IssueTransfer(USBTransfer transfer) { #if UHCI_TRACE BasicConsole.WriteLine("UHCI: Issue Transfer"); BasicConsole.DelayOutput(5); #endif UHCITransaction firstTransaction = (UHCITransaction)((USBTransaction)transfer.transactions[0]).underlyingTz; UHCITransaction lastTransaction = (UHCITransaction)((USBTransaction)transfer.transactions[transfer.transactions.Count - 1]).underlyingTz; UHCI_qTD.SetIntOnComplete(lastTransaction.qTD, true); // We want an interrupt after complete transfer CreateQH((UHCI_QueueHead_Struct *)transfer.underlyingTransferData, (uint)transfer.underlyingTransferData, firstTransaction.qTD); #if UHCI_TRACE BasicConsole.WriteLine(" Queue head data:"); BasicConsole.DumpMemory(transfer.underlyingTransferData, sizeof(UHCI_QueueHead_Struct)); BasicConsole.WriteLine(" Transactions data:"); for (int i = 0; i < transfer.transactions.Count; i++) { BasicConsole.Write(" "); BasicConsole.Write(i); BasicConsole.WriteLine(" : "); BasicConsole.WriteLine(" - qTD:"); BasicConsole.DumpMemory( ((UHCITransaction)((USBTransaction)transfer.transactions[i]).underlyingTz).qTD, sizeof(UHCI_qTD_Struct)); BasicConsole.WriteLine(" - qTDBuffer:"); BasicConsole.DumpMemory( ((UHCITransaction)((USBTransaction)transfer.transactions[i]).underlyingTz).qTDBuffer, 16); } BasicConsole.DelayOutput(60); BasicConsole.WriteLine("UHCI: Issuing transfer..."); #endif for (byte i = 0; i < UHCI_Consts.NUMBER_OF_UHCI_RETRIES && !transfer.success; i++) { TransactionsCompleted = 0; for (int j = 0; j < transfer.transactions.Count; j++) { USBTransaction elem = (USBTransaction)transfer.transactions[j]; UHCITransaction uT = (UHCITransaction)(elem.underlyingTz); uT.qTD->u1 = uT.qTD->u1 & 0xFF00FFFF; UHCI_qTD.SetActive(uT.qTD, true); } // stop scheduler USBSTS.Write_UInt16(UHCI_Consts.STS_MASK); USBCMD.Write_UInt16((ushort)(USBCMD.Read_UInt16() & ~UHCI_Consts.CMD_RS)); while ((USBSTS.Read_UInt16() & UHCI_Consts.STS_HCHALTED) == 0) { Hardware.Devices.Timer.Default.Wait(10); } // update scheduler uint qhPhysAddr = ((uint)VirtMemManager.GetPhysicalAddress(transfer.underlyingTransferData) | UHCI_Consts.BIT_QH); FrameList[0] = qhPhysAddr; FRBASEADD.Write_UInt32((uint)VirtMemManager.GetPhysicalAddress(FrameList)); FRNUM.Write_UInt16(0); // start scheduler USBSTS.Write_UInt16(UHCI_Consts.STS_MASK); USBCMD.Write_UInt16((ushort)(USBCMD.Read_UInt16() | UHCI_Consts.CMD_RS)); while ((USBSTS.Read_UInt16() & UHCI_Consts.STS_HCHALTED) != 0) { Hardware.Devices.Timer.Default.Wait(10); } #if UHCI_TRACE BasicConsole.WriteLine(((FOS_System.String) "USBINT val: ") + USBINTR.Read_UInt16()); #endif // run transactions bool active = true; int timeout = 100; //5 seconds while (active && timeout > 0) { active = false; for (int j = 0; j < transfer.transactions.Count; j++) { USBTransaction elem = (USBTransaction)transfer.transactions[j]; UHCITransaction uT = (UHCITransaction)(elem.underlyingTz); active = active || ((uT.qTD->u1 & 0x00FF0000) == 0x00800000); } Hardware.Devices.Timer.Default.Wait(50); timeout--; } #if UHCI_TRACE BasicConsole.WriteLine("Finished waiting."); #endif FrameList[0] = UHCI_Consts.BIT_T; if (timeout == 0 || TransactionsCompleted != transfer.transactions.Count) { #if UHCI_TRACE BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("UHCI: Error! Transactions wait timed out or wrong number of transactions completed."); BasicConsole.SetTextColour(BasicConsole.default_colour); BasicConsole.WriteLine(((FOS_System.String) "Transactions completed: ") + TransactionsCompleted); if (timeout == 0) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("UHCI: Error! Transfer timed out."); BasicConsole.SetTextColour(BasicConsole.default_colour); } #endif transfer.success = false; bool completeDespiteNoInterrupt = true; for (int j = 0; j < transfer.transactions.Count; j++) { USBTransaction elem = (USBTransaction)transfer.transactions[j]; UHCITransaction uT = (UHCITransaction)(elem.underlyingTz); #if UHCI_TRACE BasicConsole.WriteLine(((FOS_System.String) "u1=") + uT.qTD->u1 + ", u2=" + uT.qTD->u2); BasicConsole.WriteLine(((FOS_System.String) "Status=") + (byte)(uT.qTD->u1 >> 16)); #endif completeDespiteNoInterrupt = completeDespiteNoInterrupt && isTransactionSuccessful(uT); } transfer.success = completeDespiteNoInterrupt; #if UHCI_TRACE BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine(((FOS_System.String) "Complete despite no interrupts: ") + completeDespiteNoInterrupt); BasicConsole.SetTextColour(BasicConsole.default_colour); BasicConsole.DelayOutput(5); #endif } else { transfer.success = true; } if (transfer.success) { // check conditions and save data for (int j = 0; j < transfer.transactions.Count; j++) { USBTransaction elem = (USBTransaction)transfer.transactions[j]; UHCITransaction uT = (UHCITransaction)(elem.underlyingTz); transfer.success = transfer.success && isTransactionSuccessful(uT); // executed w/o error if (uT.inBuffer != null && uT.inLength != 0) { MemoryUtils.MemCpy_32((byte *)uT.inBuffer, (byte *)uT.qTDBuffer, uT.inLength); } } } #if UHCI_TRACE if (!transfer.success) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("UHCI: Transfer failed."); BasicConsole.SetTextColour(BasicConsole.default_colour); } else { BasicConsole.SetTextColour((char)0x0200); BasicConsole.WriteLine("Transfer succeeded."); BasicConsole.SetTextColour(BasicConsole.default_colour); } #endif } }
public static void *NewString(int length) { if (!Enabled) { BasicConsole.SetTextColour(BasicConsole.warning_colour); BasicConsole.WriteLine("Warning! GC returning null pointer because GC not enabled."); BasicConsole.Write("Last disabler: "); BasicConsole.WriteLine(lastDisabler); BasicConsole.DelayOutput(10); BasicConsole.SetTextColour(BasicConsole.default_colour); return(null); } #if GC_TRACE if (OutputTrace) { BasicConsole.WriteLine("NewString"); } #endif EnterCritical("NewString"); try { if (length < 0) { BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't create a new string because \"length\" is less than 0."); BasicConsole.DelayOutput(5); BasicConsole.SetTextColour(BasicConsole.default_colour); ExceptionMethods.Throw_OverflowException(); } InsideGC = true; //Alloc space for GC header that prefixes object data //Alloc space for new string object //Alloc space for new string chars uint totalSize = ((FOS_System.Type) typeof(FOS_System.String)).Size; totalSize += /*char size in bytes*/ 2 * (uint)length; totalSize += (uint)sizeof(GCHeader); GCHeader *newObjPtr = (GCHeader *)Heap.AllocZeroed(totalSize, "GC : NewString"); if ((UInt32)newObjPtr == 0) { InsideGC = false; BasicConsole.SetTextColour(BasicConsole.error_colour); BasicConsole.WriteLine("Error! GC can't create a new string because the heap returned a null pointer."); BasicConsole.DelayOutput(10); BasicConsole.SetTextColour(BasicConsole.default_colour); return(null); } NumStrings++; //Initialise the GCHeader SetSignature(newObjPtr); //RefCount to 0 initially because of FOS_System.String.New should be used // - In theory, New should be called, creates new string and passes it back to caller // Caller is then required to store the string in a variable resulting in inc. // ref count so ref count = 1 in only stored location. // Caller is not allowed to just "discard" (i.e. use Pop IL op or C# that generates // Pop IL op) so ref count will always at some point be incremented and later // decremented by managed code. OR the variable will stay in a static var until // the OS exits... newObjPtr->RefCount = 0; FOS_System.String newStr = (FOS_System.String)Utilities.ObjectUtilities.GetObject(newObjPtr + 1); newStr._Type = (FOS_System.Type) typeof(FOS_System.String); newStr.length = length; //Move past GCHeader byte *newObjBytePtr = (byte *)(newObjPtr + 1); InsideGC = false; return(newObjBytePtr); } finally { ExitCritical(); } }