kernel panic handler

include/Tier0/paging.h

@@ -7,4 +7,5 @@ void paging_init_simple(void);
 u8 paging_get_physical(u32 Virtual, u32 *Physical);
 void paging_map_kernel_page(u32 Virtual, u32 Physical);
 void paging_map_kernel_table(u32 Virtual, u32 Physical);
+
 #endif

include/Tier0/panic.h

@@ -0,0 +1,12 @@
+#ifndef __PANIC_H__
+#define __PANIC_H__
+
+#include "types.h"
+
+#define PANIC(m) kpanic(m, __FILE__, __LINE__)
+#define ASSERT(m) kassert(m, __FILE__, __LINE__)
+
+void kpanic(const s8 *Error, const s8 *File, u32 Line);
+void kassert(u8 Value, const s8 *File, u32 Line);
+
+#endif

include/Tier1/Drivers/Device/CDriverRamdisk.h

@@ -0,0 +1,32 @@
+#ifndef __CDRIVERRAMDISK_H__
+#define __CDRIVERRAMDISK_H__
+
+#include "Tier1/Drivers/IDriver.h"
+#include "Tier1/Drivers/IDevice.h"
+#include "Tier1/CKernel.h"
+
+namespace cb {
+    class CDriverRamdisk : public IDriver, IDevice {
+        public:
+            // Driver interface
+            const s8 *GetName(void);
+            const s8 *GetDescription(void);
+            const s8 *GetAuthor(void);
+            EDriverClass GetClass(void);
+            EDriverLoadMethod GetLoadMethod(void);
+            bool CanUnload(void);
+            
+            u8 Load(CKernel *Kernel);
+            u8 Unload(void);
+            
+            // Device interace
+            u32 GetSize(void);
+            const u8 *Read(u32 Offset, u32 Length);
+            void Write(u32 Offset, u32 Length, const u8 *Data);
+            IDeviceOperations GetSupportedOperations(void);
+        private:
+            CKernel *m_Kernel;
+    };
+};
+
+#endif

include/Tier1/Drivers/IDevice.h

@@ -0,0 +1,21 @@
+#ifndef __IDEVICE_H__
+#define __IDEVICE_H__
+
+#include "types.h"
+
+namespace cb {
+    enum IDeviceOperations {
+        IDO_GET_SIZE = 1,
+        IDO_READ = 2,
+        IDO_WRITE = 4
+    };
+    class IDevice {
+        public:
+            virtual u32 GetSize(void) = 0;
+            virtual const u8 *Read(u32 Offset, u32 Length) = 0;
+            virtual void Write(u32 Offset, u32 Length, const u8 *Data) = 0;
+            virtual IDeviceOperations GetSupportedOperations(void) = 0;
+    };
+};
+
+#endif

include/Tier1/Drivers/IDriver.h

@@ -10,6 +10,7 @@ namespace cb {
     enum EDriverClass {
         EDC_NONE,
         EDC_FILESYSTEM,
+        EDC_DEVICE,
         BDC_BLOCKDEVICE
     };
     enum EDriverLoadMethod {

src/Tier0/panic.c

@@ -0,0 +1,88 @@
+#include "Tier0/panic.h"
+#include "Tier0/kstdio.h"
+
+#define KPANIC_HEADER "**** KERNEL PANIC ****"
+
+void kpanic(const s8 *Error, const s8 *File, u32 Line)
+{
+    __asm__ volatile("cli");
+    
+    kclear();
+    
+    u8 Margin = (80 - kstrlen(KPANIC_HEADER)) / 2;
+    
+    for (u8 i = 0; i < Margin; i++)
+        kprintf(" ");
+    
+    kprintf(KPANIC_HEADER);
+    kprintf("\n");
+    
+    kprintf("\n");
+    
+    Margin = (80 - kstrlen(Error)) / 2;
+    for (u8 i = 0; i < Margin; i++)
+        kprintf(" ");
+    kprintf("%s\n", Error);
+    
+    Margin = (62 - kstrlen(File)) / 2;
+    for (u8 i = 0; i < Margin; i++)
+        kprintf(" ");
+    
+    kprintf(" in file %s, line %i\n", File, Line);
+    
+    // Dumping registers
+    
+    kprintf("\n  register dump:\n");
+    
+    u32 cr0, cr3, eax, ebx, ecx, edx, esi, edi, ebp, esp, cs, ds;
+    __asm__ volatile("mov %%cr0, %0": "=r"(cr0));
+    __asm__ volatile("mov %%cr3, %0": "=r"(cr3));
+    
+    __asm__ volatile("mov %%eax, %0": "=r"(eax));
+    __asm__ volatile("mov %%ebx, %0": "=r"(ebx));
+    __asm__ volatile("mov %%ecx, %0": "=r"(ecx));
+    __asm__ volatile("mov %%edx, %0": "=r"(edx));
+    
+    __asm__ volatile("mov %%esi, %0": "=r"(esi));
+    __asm__ volatile("mov %%edi, %0": "=r"(edi));
+    __asm__ volatile("mov %%ebp, %0": "=r"(ebp));
+    __asm__ volatile("mov %%esp, %0": "=r"(esp));
+    
+    __asm__ volatile("mov %%cs, %0": "=r"(cs));
+    __asm__ volatile("mov %%ds, %0": "=r"(ds));
+    
+    kprintf("        cr0: 0x%X cr3: 0x%x  cs: 0x%x  ds: 0x%x\n",
+        cr0, cr3, cs, ds);
+    kprintf("        eax: 0x%X ebx: 0x%x ecx: 0x%x edx: 0x%x\n",
+        eax, ebx, ecx, edx);
+    kprintf("        esi: 0x%X edi: 0x%x ebp: 0x%x esp: 0x%x\n",
+        esi, edi, ebp, esp);
+    
+    s32 FrameSize = ebp - esp;
+    
+    if (FrameSize > 0 && FrameSize < 0x100)
+    {
+        kprintf("\n  stack frame looks promising...\n");
+        kprintf("  attempting stack dump:\n");
+        
+        u32 Number = 80;
+        for (u32 *v = (u32*)esp; v < ((u32 *)esp + Number); v+=8)
+        {
+            kprintf("    %x %x %x %x %x %x %x %x\n",
+               *v, *(v+1), *(v+2), *(v+3), *(v+4), *(v+5), *(v+6), *(v+7));
+        }
+    }
+    else
+        kprintf("\n  stack looks unusable, not dummping.\n");
+    
+    kprintf("\n  if you want to keep using the OS, please reset your PC.");
+    
+    for(;;){}
+}
+
+void kassert(u8 Value, const s8* File, u32 Line)
+{
+    if (Value == 0)
+        kpanic("assertion error", File, Line);
+}
+

src/Tier1/CKernel.cpp

@@ -1,11 +1,13 @@
 #include "Tier1/CKernel.h"
 #include "Tier1/Drivers/Misc/CDriverDummy.h"
+#include "Tier1/Drivers/Device/CDriverRamdisk.h"
 using namespace cb;
 
 CKernel g_Kernel;
 
 extern "C" {
     #include "Tier0/kstdio.h"
+    #include "Tier0/panic.h"
     
     void CKernelStart(void)
     {
@@ -39,8 +41,12 @@ void CKernel::Start(void)
     IDriver *Dummy = new CDriverDummy();
     m_DriverManager->AddDriver(Dummy);
     
+    IDriver *Ramdisk = new CDriverRamdisk();
+    m_DriverManager->AddDriver(Ramdisk);
+    
     m_DriverManager->LoadNew();
     
+    ASSERT(0);
     
     for (;;) {}
 }

src/Tier1/Drivers/Device/CDriverRamdisk.cpp

@@ -0,0 +1,46 @@
+#include "Tier1/Drivers/Device/CDriverRamdisk.h"
+using namespace cb;
+
+const s8 *CDriverRamdisk::GetDescription(void)
+{ return "Ramdisk Driver"; }
+const s8 *CDriverRamdisk::GetName(void)
+{ return "org.q3k.drivers.ramdisk"; }
+const s8 *CDriverRamdisk::GetAuthor(void)
+{ return "Sergiusz Bazanski"; }
+EDriverClass CDriverRamdisk::GetClass(void)
+{ return EDC_DEVICE; }
+EDriverLoadMethod CDriverRamdisk::GetLoadMethod(void)
+{ return EDLM_ALWAYS; }
+bool CDriverRamdisk::CanUnload(void)
+{ return false; }
+
+u8 CDriverRamdisk::Load(CKernel *Kernel)
+{
+    m_Kernel = Kernel;    
+    return 0;
+}
+
+u8 CDriverRamdisk::Unload(void)
+{
+    return 0;
+}
+
+u32 CDriverRamdisk::GetSize(void)
+{
+    return 2;
+}
+
+const u8 *CDriverRamdisk::Read(u32 Offset, u32 Length)
+{
+    return (u8*)"lo";
+}
+
+void CDriverRamdisk::Write(u32 Offset, u32 Length, const u8 *Data)
+{
+    return;
+}
+
+IDeviceOperations CDriverRamdisk::GetSupportedOperations(void)
+{
+    return (IDeviceOperations)(IDO_GET_SIZE | IDO_READ);
+}

src/Tier1/Drivers/Misc/CDriverDummy.cpp

@@ -34,8 +34,8 @@ bool CDriverDummy::CanUnload(void)
 u8 CDriverDummy::Load(CKernel *Kernel)
 {
     m_Kernel = Kernel;
-    Kernel->Logger() << "Dummy driver loaded!";
-    Kernel->Logger().Flush();
+    //Kernel->Logger() << "Dummy driver loaded!";
+    //Kernel->Logger().Flush();
     
     return 0;
 }