private void RangeCheck(uint value, uint max, string name) { if (value > max) { DebugStub.Break(); } }
public void Write32(int offset, uint value) { if (!PciPortHandle.Write32(handle, offset, value)) { DebugStub.Break(); } }
public override void EnableIrq(byte irq) { if (irq >= INTCPS_Vectors) { DebugStub.Break(); // throw new OverflowException // (String.Format("irq {0} out of range.", irq)); } #if DEBUG_INTERRUPTS DebugStub.WriteLine("Int{0:x2} Enable, Mask={3:x8}{2:x8}{1:x8}", __arglist(irq, irqMask0, irqMask1, irqMask2)); #endif bool saved = Processor.DisableInterrupts(); try { Unmask(irq); #if PIC_DEBUG DumpRegisters(); #endif } finally { Processor.RestoreInterrupts(saved); } }
public Bytes GetNextBuffer(out int start, out int length) { if (this.Empty) { start = -1; length = -1; return(null); } if (this.currentTxBuff == null) { this.currentTxBuff = this.listHead.next; this.currentTxTotalOffset = 0; this.currentTxBufferOffset = this.currentTxBuff.startOffset; } else { this.currentTxBuff = this.currentTxBuff.next; this.currentTxBufferOffset = this.currentTxBuff.startOffset; if (this.currentTxBuff == this.listTail) { DebugStub.Print("GetBuffer: Empty list???\n"); DebugStub.Break(); start = -1; length = -1; return(null); } } start = (int)this.currentTxBuff.startOffset; length = (int)this.currentTxBuff.length; return(this.currentTxBuff.data); }
public Bytes PopAllPackets() { Bytes packet; int sizeOfData; Bytes buffer; if (byteCount <= 0) { DebugStub.WriteLine("UDP PopAllPackets: no data???\n"); DebugStub.Break(); return(null); } using (thisLock.Lock()) { DebugPrint("Popping {0} bytes of data to client\n", byteCount); buffer = new Bytes(new byte[byteCount]); VectorQueueByte incomingPacketQueue = packetContainer.Acquire(); int offset = 0; while ((packet = incomingPacketQueue.ExtractHead()) != null) { VTable.Assert(packet != null); Bitter.Copy(buffer, offset, packet.Length, packet, 0); offset += packet.Length; byteCount -= packet.Length; //delete packet; } packetContainer.Release(incomingPacketQueue); DebugStub.Assert(byteCount == 0); } return(buffer); }
public void Write8(int offset, byte value) { if (!PciPortHandle.Write8(handle, offset, value)) { DebugStub.Break(); } }
public static void Assert(bool assertion) { if (!assertion) { DebugStub.WriteLine("assertion failure, stack trace:"); #if !SINGULARITY StackTrace st = new StackTrace(true); string stackIndent = ""; for (int i = 0; i < st.FrameCount; i++) { // Low down the call stack there are four // stack frames, one for each method invocation. StackFrame sf = st.GetFrame(i); Console.WriteLine("\n" + stackIndent + " Method: {0}", sf.GetMethod()); Console.WriteLine(stackIndent + " File: {0}", sf.GetFileName()); Console.WriteLine(stackIndent + " Line Number: {0}", sf.GetFileLineNumber()); stackIndent += " "; } #endif DebugStub.Break(); throw new Exception("Assertion failed"); } }
internal static unsafe UIntPtr GetStackSegment(UIntPtr size, ref ThreadContext context, bool kernelAllocation, bool initialStack) { #if SINGULARITY_LINKED_STACKS #else if (!initialStack) { // If we get here, then the initial stack size must not have // been sufficient to ensure that we don't need linked stacks. DebugStub.Break(); } #endif UIntPtr begin = context.stackBegin; UIntPtr limit = context.stackLimit; #if DO_TRACE_STACKS Kernel.Waypoint(666); #endif StackHead *head = GetStackSegmentRaw(size, ref context, kernelAllocation, initialStack); if (head != null) { head->prevBegin = begin; head->prevLimit = limit; head->esp = 0; } return((UIntPtr)head); }
public static ExternalProcessState GetState(ProcessHandle handle) { Process process = HandleTable.GetHandle(handle.id) as Process; switch (process.State) { case InternalProcessState.Unstarted: case InternalProcessState.Running: return(ExternalProcessState.Active); case InternalProcessState.Suspending: case InternalProcessState.SuspendingRecursive: case InternalProcessState.Suspended: return(ExternalProcessState.Suspended); case InternalProcessState.Stopping: case InternalProcessState.Stopped: return(ExternalProcessState.Stopped); default: // handle new missing case DebugStub.Break(); return(ExternalProcessState.Stopped); } }
private void TxExchange() { int toCount = 0; int fromCount = 0; NicDeviceContract /*.Imp*/ imp = (NicDeviceContract)nicChannel.Acquire(); try { PacketFifo src = this.txFifo.Acquire(); PacketFifo free = this.txFreeFifo.Acquire(); toCount = src.Count; try { src = imp.GiveTxPacketsToDevice(src); fromCount = src.Count; free.Push(src); } finally { this.txFreeFifo.Release(free); this.txFifo.Release(src); } } catch (Exception e) { DebugStub.Print("TxExchange FAILED arg {0}\n", DebugStub.ArgList(e.ToString())); DebugStub.Break(); } finally { nicChannel.Release(imp); } DebugPrint("TxExchange out: {0} in: {1}\n", toCount, fromCount); }
//| <include path='docs/doc[@for="Assert.Fail"]/*' /> public static void Fail(String conditionString, String message) { // Run through the list of filters backwards (the last filter in the list // is the default filter. So we're guaranteed that there will be at least // one filter to handle the assert. int iTemp = iNumOfFilters; while (iTemp > 0) { AssertFilters iResult = ListOfFilters [--iTemp].AssertFailure(conditionString, message); if (iResult == AssertFilters.FailDebug) { #if SINGULARITY_KERNEL DebugStub.Break(); #elif SINGULARITY_PROCESS VTable.DebugBreak(); #endif break; } else if (iResult == AssertFilters.FailTerminate) #if SINGULARITY_KERNEL { Kernel.Shutdown(-1); } #elif SINGULARITY_PROCESS { AppRuntime.Stop(-1); }
// template for static creation method new public static EachSourceClass Create(string sourcename, uint size, uint storageOptions, uint sourceFlags) { EventingStorage storage = EventingStorage.CreateLocalStorage(storageOptions, size); if (storage == null) { DebugStub.WriteLine("Failure to create local storage " + sourcename); DebugStub.Break(); return(null); } EachSourceClass Source = new EachSourceClass_Impl(sourcename, storage, sourceFlags); if (Source != null) { if (!Source.Register()) { DebugStub.WriteLine("Error initializing the source " + sourcename); return(null); } } return(Source); }
public static void DeferedUpdateNotification() { uint CapturedValue = DeferedCommand; DeferedCommand = 0; // TODO: This needs to be be moved later in a work item thread pool mechanism // of some sort if ((CapturedValue & DEFERED_COMMAND_ENABLE_KERNEL_GC) != 0) { // TODO: This API has disappeared in the arm branch // - may need to get moved to a new API // GCProfilerLogger.StartProfiling(); } if ((CapturedValue & DEFERED_COMMAND_FORCE_GC_COLLECTION) != 0) { DebugStub.WriteLine("Kernel GC collection started\n"); System.GC.Collect(); System.GC.WaitForPendingFinalizers(); System.GC.Collect(); DebugStub.WriteLine("Kernel GC collection completed\n"); DebugStub.Break(); } }
// Returns true if the channel allows writing private bool CanWrite(TcpConnectionContract /*.Imp*/ conn) { if (conn.InState(TcpConnectionContract.State.Connected /*.Value*/)) { return(true); } // else if(conn.InState(TcpConnectionContract.SendOnly/*.Value*/)) { // return true; // } // if (conn.InState(TcpConnectionContract.ReceiveOnly/*.Value*/)) { // DebugStub.Break(); // return false; // } if (conn.InState(TcpConnectionContract.State.ReadyState /*.Value*/)) { DebugStub.Break(); return(false); } if (conn.InState(TcpConnectionContract.State.Listening /*.Value*/)) { DebugStub.Break(); return(false); } return(false); }
public Bytes ExtractHead(out uint startOffset, out uint length) { if (this.Empty) { startOffset = 0; length = 0; return(null); } TcpVectorNode candidate = this.listHead.next; Bytes data = candidate.Unlink(); count--; if (data != null) { size -= candidate.length; } else { DebugStub.WriteLine("Extracthead no data??\n"); DebugStub.Break(); VTable.Assert(false); } startOffset = candidate.startOffset; length = candidate.length; return(data); }
//push a single packet onto the ring void IAdapter.PopulateTxRing(Bytes header, Bytes data) { try { PacketFifo txFree = this.txFreeFifo.Acquire(); PacketFifo txToDevice = this.txFifo.Acquire(); DebugPrint("populate tx ring\n"); try { Packet packet = txFree.Pop(); packet.SetFragment(0, header); packet.SetFragment(1, data); txToDevice.Push(packet); } finally { this.txFreeFifo.Release(txFree); this.txFifo.Release(txToDevice); } } catch (Exception e) { DebugStub.Print("Populate tx ring failed?? {0}\n", DebugStub.ArgList(e)); DebugStub.Break(); } //When to exchange? //how do we best manage the tradeoff of throughput and latency? //to begin let's just send one at a time. //I think i'd rather have another thread.... using (thisLock.Lock()) { TxExchange(); } }
private void DispatchRequest(object dispatchObject) { Console.WriteLine(dispatchObject as string); Console.WriteLine("We should Never get here"); #if SINGULARITY DebugStub.Break(); #endif }
private void DebugBreak() { #if SINGULARITY_KERNEL DebugStub.Break(); #elif SINGULARITY_PROCESS DebugService.Break(); #endif // SINGULARITY_PROCESS }
public static int DriverMain(IntelResources resources) { ExtensionContract /*.Exp*/ ep = (resources.ec).Acquire(); ServiceProviderContract /*.Exp*/ sp = (resources.nicsp).Acquire(); Intel device = new Intel(resources); device.Initialize(); ep.SendSuccess(); try { for (bool run = true; run;) { switch receive { case sp.Connect(ServiceContract /*.Exp*/ exp): NicDeviceContract /*.Exp*/ nd = exp as NicDeviceContract /*.Exp*/; if (nd != null) { Tracing.Log(Tracing.Debug, "Connect success."); sp.SendAckConnect(); IntelDeviceChannel.CreateThread(device, nd); } else { Tracing.Log(Tracing.Error, "Connect failed."); sp.SendNackConnect(exp); } break; case sp.ChannelClosed(): device.Shutdown(); run = false; break; case ep.Shutdown(): device.Shutdown(); ep.SendAckShutdown(); break; case ep.ChannelClosed(): device.Shutdown(); run = false; break; case unsatisfiable: DebugStub.Break(); break; } } } finally { //delete ep; //delete sp; } return(0); }
// // This is invoked on SIP OOM to "fail-fast" the SIP // internal static void UserMemoryFailure() { DebugStub.WriteLine("******** SIP OOM on Heap, Failing Fast ********"); // This does not make a stack transition record Thread.CurrentProcess.Stop((int)System.ProcessExitCode.ErrorDefault); // Should not return DebugStub.Break(); }
internal UIntPtr AllocateExtend(UIntPtr addr, UIntPtr bytes, Process process, uint extra, PageType type) { // TODO: Extend not yet implemented DebugStub.Break(); return((UIntPtr)null); }
internal PageType Query(UIntPtr queryAddr, Process process, out UIntPtr regionAddr, out UIntPtr regionSize) { // TODO: Query not yet implemented DebugStub.Break(); regionAddr = 0; regionSize = 0; return(0); }
/// <summary> /// Look up the Monitor for the specified object in the SyncBlock /// tables. If no Monitor exists for the object then one is created. /// </summary> private static Monitor GetMonitorFromObject(Object obj) { if (obj == null) { DebugStub.Break(); throw new ArgumentNullException("obj"); } Monitor result = MultiUseWord.GetMonitor(obj); return(result); }
//dups? //XXX fix the dupes! public bool RegisterAdapter(IAdapter adapter) { if (adapters.Contains(adapter)) { DebugStub.Print("Duplicate adapters???\n"); DebugStub.Break(); return(false); } adapters.Add(adapter); return(true); }
//push a single packet onto the ring void IAdapter.PopulateTxRing(Bytes header, Bytes data) { try { PacketFifo txFree = this.txFreeFifo.Acquire(); PacketFifo txCoalesce = this.txCoalesceFifo.Acquire(); try { DebugStub.Assert(txFree.Count > 0); int cnt = 0; while (txFree.Count <= 0) { //try again... //this happens when we're hammering the outgoing connection this.txCoalesceFifo.Release(txCoalesce); this.txFreeFifo.Release(txFree); this.muxEvent.Set(); Thread.Yield(); txFree = this.txFreeFifo.Acquire(); txCoalesce = this.txCoalesceFifo.Acquire(); if (cnt > 100) { DebugStub.Print("txFree empty???\n"); //DebugStub.Break(); } cnt++; } Packet packet = txFree.Pop(); packet.SetFragment(0, header); packet.SetFragment(1, data); if ((txCoalesce.Count + 1) > txCoalesce.Capacity) { DebugStub.Break(); } DebugStub.Assert((txCoalesce.Count + 1) <= txCoalesce.Capacity); txCoalesce.Push(packet); } catch { DebugStub.Print("failure in populate tx ring\n"); DebugStub.Break(); DebugStub.Assert(false); } finally { this.txCoalesceFifo.Release(txCoalesce); this.txFreeFifo.Release(txFree); //notify the mux that there are waiting packets this.muxEvent.Set(); } } catch (Exception e) { DebugStub.Print("Populate tx ring failed?? {0}\n", DebugStub.ArgList(e)); DebugStub.Break(); } }
/// <summary> /// Wait to be woken up by a holder of the monitor. Give up after /// a specified timeout. /// /// Overload exists to match the CLR. Exit Context not supported. /// </summary> public static bool Wait(Object obj, TimeSpan timeout, bool exitContext) { if (exitContext) { DebugStub.Break(); throw new NotSupportedException("exitContext not supported!"); } Monitor monitor = GetMonitorFromObject(obj); return(monitor.Wait(SchedulerTime.Now + timeout)); }
private static void AnnounceApFail(int nextCpu) { MpSyncState localMpState = mpSyncState; DebugStub.Print("MpState {0}", __arglist(localMpState)); DebugStub.Break(); Platform bi = Platform.ThePlatform; DebugStub.Print("Cpu {0} failed. ", __arglist(nextCpu)); DebugStub.Print("GotBack-> Status {0} Count {1:x8}\n", __arglist(bi.MpStatus32, bi.MpCpuCount)); }
private unsafe byte Read8Impl(int offset) { byte v; if (PciPortHandle.Read8Impl(handle, offset, &v)) { return(v); } else { DebugStub.Break(); return(0); } }
/// <summary> /// Exit the monitor. /// </summary> internal void Exit() { if (!mutex.IsOwnedByCurrentThread()) { DebugStub.Break(); throw new SynchronizationLockException("Monitor not held on Exit"); } depth--; if (depth == 0) { mutex.ReleaseMutex(); } }
private unsafe uint Read32Impl(int offset) { uint v; if (PciPortHandle.Read32Impl(handle, offset, &v)) { return(v); } else { DebugStub.Break(); return(0); } }