public static void Setup()
{
// Initialize GDT before IDT, because IDT Entries requires a valid Segment Selector
Multiboot.Setup();
GDT.Setup();
// At this stage, allocating memory does not work, so you are only allowed to use ValueTypes or static classes.
IDT.SetInterruptHandler(null);
Panic.Setup();
// Initialize interrupts
PIC.Setup();
IDT.Setup();
// Initializing the memory management
PageFrameAllocator.Setup();
PageTable.Setup();
VirtualPageAllocator.Setup();
GC.Setup();
// At this point we can use objects
Scheduler.Setup();
SmbiosManager.Setup();
ConsoleManager.Setup();
Logger.Log("Kernel initialized");
}
/// <summary>
/// Helps to track memroy changes. Checks if memroy has changed between two calls.
/// </summary>
/// <param name="startAddress"></param>
/// <param name="bytes"></param>
/// <param name="panic">Halt the kernel</param>
/// <param name="message">Display a custom message</param>
/// <returns></returns>
public static bool MemoryChanged(uint startAddress, uint bytes, bool panic = false, string message = null)
{
//Improvement: Allocate memory for multiple items and check for different input values.
var checksum = FlechterChecksum.Fletcher16(startAddress, bytes);
memoyChangedItem.beforeLastCheckum = memoyChangedItem.lastChecksum;
memoyChangedItem.lastChecksum = checksum;
memoyChangedItem.checks++;
if (memoyChangedItem.checks > 1 && memoyChangedItem.beforeLastCheckum != memoyChangedItem.lastChecksum)
{
if (panic)
{
if (message == null)
{
Panic.Error("Memory Changed Exception");
}
else
{
Panic.Error(message);
}
}
return(true);
}
else
{
return(false);
}
}
public static void Setup()
{
// At this stage, allocating memory does not work, so you are only allowed to use ValueTypes or static classes.
IDT.SetInterruptHandler(null);
Panic.Setup();
Debugger.Setup(Serial.COM1);
// Initialize interrupts
PIC.Setup();
IDT.Setup();
// Initializing the memory management
Multiboot.Setup();
GDT.Setup();
PageFrameAllocator.Setup();
PageTable.Setup();
VirtualPageAllocator.Setup();
GC.Setup();
// At this point we can use objects
Scheduler.Setup();
SmbiosManager.Setup();
ConsoleManager.Setup();
Internal.Setup();
}
public static void Setup()
{
// Initialize GDT before IDT, because IDT Entries requies a valid Segment Selector
// This never happend before, because on fast computers GDT.Setup() was called
// before a Interrupt,for example clock, got triggered.
Multiboot.Setup();
GDT.Setup();
// At this stage, allocating memory does not work, so you are only allowed to use ValueTypes or static classes.
IDT.SetInterruptHandler(null);
Panic.Setup();
Debugger.Setup(Serial.COM1);
// Initialize interrupts
PIC.Setup();
IDT.Setup();
// Initializing the memory management
PageFrameAllocator.Setup();
PageTable.Setup();
VirtualPageAllocator.Setup();
GC.Setup();
// At this point we can use objects
Scheduler.Setup();
SmbiosManager.Setup();
ConsoleManager.Setup();
Internal.Setup();
}
/// <summary>
/// Interrupts the handler.
/// </summary>
/// <param name="stackStatePointer">The stack state pointer.</param>
private unsafe static void ProcessInterrupt(uint stackStatePointer)
{
//KernelMessage.WriteLine("Interrupt occured");
var stack = (IDTStack *)stackStatePointer;
var irq = stack->Interrupt;
var info = IDTManager.handlers[irq];
IDTManager.RaisedCount++;
if (info.CountStatistcs)
{
IDTManager.RaisedCountCustom++;
}
if (info.Trace)
{
KernelMessage.WriteLine("Interrupt: {0}", irq);
}
var col = Screen.column;
var row = Screen.row;
Screen.column = 0;
Screen.Goto(2, 35);
Screen.Write("Interrupts: ");
Screen.Write(IDTManager.RaisedCount);
Screen.Goto(3, 35);
Screen.Write("IntNoClock: ");
Screen.Write(IDTManager.RaisedCountCustom);
Screen.row = row;
Screen.column = col;
if (irq < 0 || irq > 255)
{
Panic.Error("Invalid Interrupt");
}
if (info.Handler == null)
{
//Panic.Error("Handlr is null");
}
else
{
}
info.Handler(stack);
PIC.SendEndOfInterrupt(irq);
}
/// <summary>
/// Creates the process.
/// </summary>
/// <returns></returns>
public static uint CreateProcess()
{
// TODO: Lock
uint slot = FindEmptySlot();
if (slot == 0)
{
Panic.Now(5);
}
CreateProcess(slot);
// TODO: Unlock
return(slot);
}
/// <summary>
/// Creates the task.
/// </summary>
/// <returns></returns>
public static uint CreateTask(uint processid, uint eip)
{
// TODO: Lock
uint slot = FindEmptySlot();
if (slot == 0)
{
Panic.Now(5);
}
CreateTask(processid, slot, eip);
// TODO: Unlock
return(slot);
}
private unsafe static void Error(IDTStack *stack, string message)
{
Panic.ESP = stack->ESP;
Panic.EBP = stack->EBP;
Panic.EIP = stack->EIP;
Panic.EAX = stack->EAX;
Panic.EBX = stack->EBX;
Panic.ECX = stack->ECX;
Panic.EDX = stack->EDX;
Panic.EDI = stack->EDI;
Panic.ESI = stack->ESI;
Panic.CS = stack->CS;
Panic.ErrorCode = stack->ErrorCode;
Panic.EFLAGS = stack->EFLAGS;
Panic.Interrupt = stack->Interrupt;
Panic.Error(message);
}
/// <summary>
/// Handle Page Faults
/// </summary>
/// <param name="errorCode">The error code.</param>
public static void Fault(uint errorCode)
{
uint virtualpage = Native.GetCR2();
if (virtualpage == 0x0)
{
Panic.Now(2); // Can't map null! what happened?
}
// TODO: acquire lock
uint physicalpage = PageFrameAllocator.Allocate();
if (physicalpage == 0x0)
{
Panic.Now(1); // Panic! Out of memory
}
PageTable.MapVirtualAddressToPhysical(virtualpage, physicalpage);
// TODO: release lock
}
/// <summary>
/// Handle Page Faults
/// </summary>
/// <param name="errorCode">The error code.</param>
public static void Fault(uint errorCode)
{
uint virtualpage = Native.GetCR2();
if (virtualpage == 0x0)
{
Panic.Now(2); // Can't map null! what happened?
}
//bool taken = false;
//spinLock.Enter(ref taken);
uint physicalpage = PageFrameAllocator.Allocate();
if (physicalpage == 0x0)
{
Panic.Now(1); // Panic! Out of memory
}
PageTable.MapVirtualAddressToPhysical(virtualpage, physicalpage);
//spinLock.Exit();
}
private static void Error(uint ebp, uint eip, string message)
{
Panic.SetStackPointer(ebp, eip);
Panic.Error(message);
}
/// <summary>
/// Interrupts the handler.
/// </summary>
/// <param name="stack">The stack.</param>
private unsafe static void ProcessInterrupt(IDTStack *stack)
{
DebugClient.Process();
switch (stack->Interrupt)
{
case 0:
Error(stack->EBP, stack->EIP, "Divide Error");
break;
case 4:
Error(stack->EBP, stack->EIP, "Arithmetic Overflow Exception");
break;
case 5:
Error(stack->EBP, stack->EIP, "Bound Check Error");
break;
case 6:
Error(stack->EBP, stack->EIP, "Invalid Opcode");
break;
case 7:
Error(stack->EBP, stack->EIP, "Co-processor Not Available");
break;
case 8:
//TODO: Analyze the double fault
Error(stack->EBP, stack->EIP, "Double Fault");
break;
case 9:
Error(stack->EBP, stack->EIP, "Co-processor Segment Overrun");
break;
case 10:
Error(stack->EBP, stack->EIP, "Invalid TSS");
break;
case 11:
Error(stack->EBP, stack->EIP, "Segment Not Present");
break;
case 12:
Error(stack->EBP, stack->EIP, "Stack Exception");
break;
case 13:
Error(stack->EBP, stack->EIP, "General Protection Exception");
break;
case 14:
// Check if Null Pointer Exception
// Otherwise handle as Page Fault
var cr2 = Native.GetCR2() >> 5;
if (cr2 < 0x1000)
{
Error(stack->EBP, stack->EIP, "Null Pointer Exception");
}
//spinLock.Enter(ref taken);
uint physicalpage = PageFrameAllocator.Allocate();
if (physicalpage == 0x0)
{
// Panic! Out of memory
Panic.SetStackPointer(stack->EBP, stack->EIP);
Panic.Error(cr2);
}
PageTable.MapVirtualAddressToPhysical(Native.GetCR2(), physicalpage);
//spinLock.Exit();
break;
case 16:
Error(stack->EBP, stack->EIP, "Co-processor Error");
break;
case 19:
Error(stack->EBP, stack->EIP, "SIMD Floating-Point Exception");
break;
default:
if (interruptHandler != null)
{
interruptHandler(stack->Interrupt, stack->ErrorCode);
}
break;
}
PIC.SendEndOfInterrupt(stack->Interrupt);
}
/// <summary>
/// Interrupts the handler.
/// </summary>
/// <param name="stack">The stack.</param>
private unsafe static void ProcessInterrupt(IDTStack *stack)
{
DebugClient.Process();
switch (stack->Interrupt)
{
case 0:
Error(stack->EBP, stack->EIP, "Divide Error");
break;
case 4:
Error(stack->EBP, stack->EIP, "Arithmetic Overflow Exception");
break;
case 5:
Error(stack->EBP, stack->EIP, "Bound Check Error");
break;
case 6:
Error(stack->EBP, stack->EIP, "Invalid Opcode");
break;
case 7:
Error(stack->EBP, stack->EIP, "Coprocessor Not Available");
break;
case 8:
//TODO: Analyze the double fault
Error(stack->EBP, stack->EIP, "Double Fault");
break;
case 9:
Error(stack->EBP, stack->EIP, "Coprocessor Segment Overrun");
break;
case 10:
Error(stack->EBP, stack->EIP, "Invalid TSS");
break;
case 11:
Error(stack->EBP, stack->EIP, "Segment Not Present");
break;
case 12:
Error(stack->EBP, stack->EIP, "Stack Exception");
break;
case 13:
Error(stack->EBP, stack->EIP, "General Protection Exception");
break;
case 14:
// Page Fault!
var cr2 = Native.GetCR2() >> 5;
if (cr2 < 0x1000)
{
Error(stack->EBP, stack->EIP, "Null Pointer Exception");
break;
}
//PageFaultHandler.Fault(errorCode);
Panic.SetStackPointer(stack->EBP, stack->EIP);
Panic.Error(cr2);
break;
case 16:
Error(stack->EBP, stack->EIP, "Coprocessor Error");
break;
case 19:
Error(stack->EBP, stack->EIP, "SIMD Floating-Point Exception");
break;
default:
if (interruptHandler != null)
{
interruptHandler(stack->Interrupt, stack->ErrorCode);
}
break;
}
PIC.SendEndOfInterrupt(stack->Interrupt);
}
