private bool Wait(WakeUp wakeUp)
{
try
{
CompilerIntrinsics.Cli();
if (waitSemaphore == null)
{
waitSemaphore = Kernel.kernel.NewSemaphore(0);
}
uint depth = lockDepth;
uint cur = Kernel.CurrentThread;
lockHolder = 0xffffffff;
lockDepth = 0;
lockSemaphore.SignalInterruptsDisabled();
bool gotIt = waitSemaphore.WaitInterruptsDisabled(wakeUp);
lockSemaphore.WaitInterruptsDisabled();
lockDepth = depth;
lockHolder = cur;
return(gotIt);
}
finally
{
CompilerIntrinsics.Sti();
}
}
internal static long GetUtcTimeInterruptsDisabled()
{
CompilerIntrinsics.Cli(); // TODO: superfluous
long tsc = NucleusCalls.Rdtsc();
return(unchecked (tsc >> 8));
}
internal bool WaitInterruptsDisabled(WakeUp wakeUp)
{
CompilerIntrinsics.Cli(); // TODO: superfluous
capacity--;
if (capacity < 0)
{
if (wakeUp != null)
{
if (wakeUp.time <= 0)
{
return(false);
}
uint cur = Kernel.CurrentThread;
wakeUp.thread = Kernel.kernel.threadTable[cur];
wakeUp.queue = waiters;
wakeUp.thread.wakeUp = wakeUp;
}
Kernel.kernel.EnqueueAndYield(waiters);
if (wakeUp != null)
{
if (wakeUp.thread.wakeUp == null)
{
// We timed out
return(false);
}
wakeUp.thread.wakeUp = null;
}
}
return(true);
}
internal static void Throw()
{
CompilerIntrinsics.Cli();
NucleusCalls.Throw();
while (true)
{
}
}
internal void WaitInterruptsDisabled()
{
CompilerIntrinsics.Cli(); // TODO: superfluous
capacity--;
if (capacity < 0)
{
Kernel.kernel.EnqueueAndYield(waiters);
}
}
public uint Read32(int offset)
{
try {
CompilerIntrinsics.Cli();
return(NucleusCalls.PciMemRead32(id, (uint)offset));
}
finally {
CompilerIntrinsics.Sti();
}
}
public void Write32(int offset, uint val)
{
try {
CompilerIntrinsics.Cli();
NucleusCalls.PciMemWrite32(id, (uint)offset, val);
}
finally {
CompilerIntrinsics.Sti();
}
}
private void KernelMain()
{
CompilerIntrinsics.Cli(); // TODO: superfluous
for (uint i = 0; i < 50 * 80; i++)
{
NucleusCalls.VgaTextWrite(i, 0);
}
Thread init = new Thread(new InitThread(), true);
_NewThread(init);
uint x = 0xe100;
uint y = 0;
while (true)
{
CompilerIntrinsics.Cli(); // TODO: superfluous
NucleusCalls.VgaTextWrite(79, x);
x++;
// Schedule thread, wait for exception or interrupt
ScheduleNextThread();
// CurrentThread received exception, interrupt, or exited voluntarily
uint cid = CurrentThread;
Thread t = threadTable[cid];
CompilerIntrinsics.Cli(); // TODO: superfluous
uint cState = NucleusCalls.GetStackState(cid);
if (cState == STACK_EMPTY)
{
// Thread received an exception. Kill it.
t.alive = false;
}
CompilerIntrinsics.Cli(); // TODO: superfluous
if (t.alive)
{
// Thread was interrupted. It's still ready to run.
NucleusCalls.SendEoi();
CheckWakeUp();
CompilerIntrinsics.Cli(); // TODO: superfluous
NucleusCalls.StartTimer(0);
readyQueue.Enqueue(t);
}
else
{
NucleusCalls.VgaTextWrite(78, (uint)(0x5b00 + 0x1100 * (y++) + 48 + cid));
// Thread is dead. Dead threads always jump back to stack 0.
threadTable[cid] = null;
NucleusCalls.ResetStack(cid);
}
}
}
/*TODO
* public byte Read8(int offset) {
* return (byte)(Read32(offset));
* }
*
* public ushort Read16(int offset) {
* return (ushort)(Read32(offset));
* }
*/
public uint Read32(int offset)
{
System.VTable.Assert((offset & 3) == 0);
try {
CompilerIntrinsics.Cli();
return(NucleusCalls.PciConfigRead32(id, (uint)offset));
}
finally {
CompilerIntrinsics.Sti();
}
}
internal static void Print(char c)
{
CompilerIntrinsics.Cli();
NucleusCalls.VgaTextWrite(offset, (uint)(0x1e00 | c));
offset++;
if (offset == 40 * 80)
{
offset = 80;
}
NucleusCalls.VgaTextWrite(offset, (uint)(0x3b00 | 33));
CompilerIntrinsics.Sti();
}
internal static uint TryReadKeyboard()
{
try
{
CompilerIntrinsics.Cli();
return(NucleusCalls.TryReadKeyboard());
}
finally
{
CompilerIntrinsics.Sti();
}
}
internal static void DebugPrintHex(uint screenOffset, uint hexMessage)
{
try
{
CompilerIntrinsics.Cli();
NucleusCalls.DebugPrintHex(screenOffset, hexMessage);
}
finally
{
CompilerIntrinsics.Sti();
}
}
public void Reset()
{
try
{
CompilerIntrinsics.Cli();
isSet = false;
}
finally
{
CompilerIntrinsics.Sti();
}
}
internal static long Rdtsc()
{
try
{
CompilerIntrinsics.Cli();
return(NucleusCalls.Rdtsc());
}
finally
{
CompilerIntrinsics.Sti();
}
}
internal PciMemory(uint id)
{
this.id = id;
try {
CompilerIntrinsics.Cli();
size = (int)NucleusCalls.PciMemSetup(id);
}
finally {
CompilerIntrinsics.Sti();
}
System.DebugStub.Print("PCI size = 0x" + size.ToString("X") + ". ");
}
internal static void VgaTextWrite(uint position, uint data)
{
try
{
CompilerIntrinsics.Cli();
NucleusCalls.VgaTextWrite(position, data);
}
finally
{
CompilerIntrinsics.Sti();
}
}
private static Array AllocateVectorInterruptsDisabled(VTable vtable, int len)
{
CompilerIntrinsics.Cli(); // TODO: superfluous
for (;;)
{
Array o = AllocateVector(vtable, len);
if (o != null)
{
return(o);
}
throw null;
}
}
private static Object AllocateObjectInterruptsDisabled(VTable vtable)
{
CompilerIntrinsics.Cli(); // TODO: superfluous
for (;;)
{
Object o = AllocateObject(vtable);
if (o != null)
{
return(o);
}
throw null;
}
}
internal void SignalInterruptsDisabled()
{
CompilerIntrinsics.Cli(); // TODO: superfluous
capacity++;
Thread t = waiters.Dequeue();
if (t != null)
{
ThreadQueue ready = Kernel.kernel.readyQueue;
ready.Enqueue(t);
Kernel.kernel.EnqueueAndYield(ready);
}
}
public Thread NewThread(ThreadStart start)
{
Thread t = new Thread(start);
try
{
CompilerIntrinsics.Cli();
return(_NewThread(t));
}
finally
{
CompilerIntrinsics.Sti();
}
}
private static Array AllocateVectorInterruptsEnabled(VTable vtable, int len)
{
CompilerIntrinsics.Cli();
for (;;)
{
Array o = AllocateVector(vtable, len);
if (o != null)
{
CompilerIntrinsics.Sti();
return(o);
}
Kernel.Collect();
CompilerIntrinsics.Cli(); // TODO: superfluous
}
}
private static Object AllocateObjectInterruptsEnabled(VTable vtable)
{
CompilerIntrinsics.Cli();
for (;;)
{
Object o = AllocateObject(vtable);
if (o != null)
{
CompilerIntrinsics.Sti();
return(o);
}
Kernel.Collect();
CompilerIntrinsics.Cli(); // TODO: superfluous
}
}
private void ThreadMain(uint id)
{
Thread t = threadTable[id];
CompilerIntrinsics.Sti();
t.start.Run();
CompilerIntrinsics.Cli();
t.alive = false;
NucleusCalls.YieldTo(0);
// Should never be reached:
NucleusCalls.DebugPrintHex(0, 0xdead0002);
while (true)
{
}
}
public void Wait()
{
try
{
CompilerIntrinsics.Cli();
capacity--;
if (capacity < 0)
{
Kernel.kernel.EnqueueAndYield(waiters);
}
}
finally
{
CompilerIntrinsics.Sti();
}
}
public override void Run()
{
int nIter = 1048576;
if (me == 0)
{
myId = Kernel.CurrentThread;
Thread otherT = kernel.NewThread(other);
uint otherId = otherT.id;
kernel.Yield();
try
{
CompilerIntrinsics.Cli();
NucleusCalls.DebugPrintHex(50, 0);
long t1 = NucleusCalls.Rdtsc();
for (int i = 0; i < nIter; i++)
{
NucleusCalls.YieldTo(otherId);
}
long t2 = NucleusCalls.Rdtsc();
uint diff = (uint)((t2 - t1) >> 20);
NucleusCalls.DebugPrintHex(50, diff);
}
finally
{
CompilerIntrinsics.Sti();
}
doneSemaphore.Signal();
}
else
{
uint otherId = other.myId;
kernel.Yield();
try
{
CompilerIntrinsics.Cli();
for (int i = 0; i < nIter; i++)
{
NucleusCalls.YieldTo(otherId);
}
}
finally
{
CompilerIntrinsics.Sti();
}
}
}
public bool TryWait()
{
try
{
CompilerIntrinsics.Cli();
if (capacity <= 0)
{
return(false);
}
capacity--;
return(true);
}
finally
{
CompilerIntrinsics.Sti();
}
}
internal static void Setup()
{
System.DebugStub.Print("Dma.Setup 1. ");
try {
CompilerIntrinsics.Cli();
ioMemory = NucleusCalls.PciDmaBuffer();
ioPhysical = NucleusCalls.PciDmaPhysicalAddr();
// The IO-MMU tables map 2MB, aligned by 2MB
uint superPageSize = 0x200000;
uint ioSuperPage = (ioPhysical + 2 * superPageSize) - (ioPhysical & (superPageSize - 1));
allocOffset = (int)(ioSuperPage - ioPhysical);
}
finally {
CompilerIntrinsics.Sti();
}
System.DebugStub.Print("Dma.Setup 2. ioPhysical = 0x" + ioPhysical.ToString("X") + " allocOffset = 0x" + allocOffset.ToString("X") + ". ");
}
public void Set()
{
try
{
CompilerIntrinsics.Cli();
isSet = true;
while (waitSemaphore.capacity != 0)
{
// signal a waiter
waitSemaphore.SignalInterruptsDisabled();
}
}
finally
{
CompilerIntrinsics.Sti();
}
}
public void Release()
{
try
{
CompilerIntrinsics.Cli();
if (lockDepth > 0)
{
lockDepth--;
return;
}
lockHolder = 0xffffffff;
lockSemaphore.SignalInterruptsDisabled();
}
finally
{
CompilerIntrinsics.Sti();
}
}
internal DmaMemory(int length)
{
System.VTable.Assert(length >= 0);
try {
CompilerIntrinsics.Cli();
this.offset = allocOffset;
this.length = length;
if (allocOffset + length <= ioMemory.Length)
{
allocOffset += length;
}
} finally {
CompilerIntrinsics.Sti();
}
if (offset + length > ioMemory.Length)
{
throw new System.Exception("DmaMemory");
}
}
