diff --git a/include/Tier0/paging.h b/include/Tier0/paging.h index 402e1e8..9e0ed00 100644 --- a/include/Tier0/paging.h +++ b/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 diff --git a/include/Tier0/panic.h b/include/Tier0/panic.h new file mode 100644 index 0000000..2853f54 --- /dev/null +++ b/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 diff --git a/include/Tier1/Drivers/Device/CDriverRamdisk.h b/include/Tier1/Drivers/Device/CDriverRamdisk.h new file mode 100644 index 0000000..424fd8b --- /dev/null +++ b/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 diff --git a/include/Tier1/Drivers/IDevice.h b/include/Tier1/Drivers/IDevice.h new file mode 100644 index 0000000..d322975 --- /dev/null +++ b/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 diff --git a/include/Tier1/Drivers/IDriver.h b/include/Tier1/Drivers/IDriver.h index 70a51a9..ea93bc6 100644 --- a/include/Tier1/Drivers/IDriver.h +++ b/include/Tier1/Drivers/IDriver.h @@ -10,6 +10,7 @@ namespace cb { enum EDriverClass { EDC_NONE, EDC_FILESYSTEM, + EDC_DEVICE, BDC_BLOCKDEVICE }; enum EDriverLoadMethod { diff --git a/src/Tier0/panic.c b/src/Tier0/panic.c new file mode 100644 index 0000000..370c222 --- /dev/null +++ b/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); +} + diff --git a/src/Tier1/CKernel.cpp b/src/Tier1/CKernel.cpp index 5116b95..cf32407 100644 --- a/src/Tier1/CKernel.cpp +++ b/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 (;;) {} } diff --git a/src/Tier1/Drivers/Device/CDriverRamdisk.cpp b/src/Tier1/Drivers/Device/CDriverRamdisk.cpp new file mode 100644 index 0000000..e4bde93 --- /dev/null +++ b/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); +} diff --git a/src/Tier1/Drivers/Misc/CDriverDummy.cpp b/src/Tier1/Drivers/Misc/CDriverDummy.cpp index 1644847..511a3bb 100644 --- a/src/Tier1/Drivers/Misc/CDriverDummy.cpp +++ b/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; }