Tasks.cpp inc/Tasks.hpp @@ -1,21 +1,21 @@ #include <Akari.hpp> #include <debug.hpp> -AkariKernel *Akari; +Kernel *Akari; -AkariKernel::AkariKernel(): Memory(0), Console(0), Descriptor(0), Timer(0), Syscall(0) { +Kernel::Kernel(): memory(0), console(0), descriptor(0), timer(0), tasks(0), syscall(0) { } /** - * Constructs an AkariKernel, using the given address as the current placement address. + * Constructs an Kernel, using the given address as the current placement address. */ -AkariKernel *AkariKernel::Construct(u32 addr, u32 upperMemory) { - AkariKernel *kernel = new ((void *)addr) AkariKernel(); - addr += sizeof(AkariKernel); - kernel->Memory = new ((void *)addr) AkariMemorySubsystem(upperMemory); - addr += sizeof(AkariMemorySubsystem); +Kernel *Kernel::Construct(u32 addr, u32 upperMemory) { + Kernel *kernel = new ((void *)addr) Kernel(); + addr += sizeof(Kernel); + kernel->memory = new ((void *)addr) Memory(upperMemory); + addr += sizeof(Memory); - kernel->Memory->setPlacementMode(addr); + kernel->memory->setPlacementMode(addr); return kernel; } Akari.cpp @@ -1,4 +1,4 @@ -#include <AkariConsoleSubsystem.hpp> +#include <Console.hpp> #include <debug.hpp> #define SCREEN_VMEM 0xb8000 @@ -9,16 +9,16 @@ #define SCREEN_BLANK 0x0720 -AkariConsoleSubsystem::AkariConsoleSubsystem() { +Console::Console() { clear(); } -u8 AkariConsoleSubsystem::versionMajor() const { return 0; } -u8 AkariConsoleSubsystem::versionMinor() const { return 1; } -const char *AkariConsoleSubsystem::versionManufacturer() const { return "Akari"; } -const char *AkariConsoleSubsystem::versionProduct() const { return "Akari Console"; } +u8 Console::versionMajor() const { return 0; } +u8 Console::versionMinor() const { return 1; } +const char *Console::versionManufacturer() const { return "Akari"; } +const char *Console::versionProduct() const { return "Akari Console"; } -void AkariConsoleSubsystem::clear() { +void Console::clear() { u16 *i = (u16 *)SCREEN_VMEM; for (u16 j = 0; j < 80 * 25; ++j, ++i) @@ -28,7 +28,7 @@ void AkariConsoleSubsystem::clear() { _updateCursor(); } -void AkariConsoleSubsystem::putChar(s8 c) { +void Console::putChar(s8 c) { switch (c) { case '\n': _shiftCursorNewline(); break; case '\t': _shiftCursorTab(); break; @@ -38,17 +38,17 @@ void AkariConsoleSubsystem::putChar(s8 c) { } } -void AkariConsoleSubsystem::putString(const char *s) { +void Console::putString(const char *s) { while (*s) putChar(*s++); } -void AkariConsoleSubsystem::putStringN(const char *s, u32 n) { +void Console::putStringN(const char *s, u32 n) { while (*s && n) putChar(*s++), --n; } -void AkariConsoleSubsystem::putInt(u32 n, u8 base) { +void Console::putInt(u32 n, u8 base) { ASSERT(base >= 2 && base <= 36); u32 index = 1, digits = 1; @@ -67,7 +67,7 @@ void AkariConsoleSubsystem::putInt(u32 n, u8 base) { } while (index >= 1); } -void AkariConsoleSubsystem::_scroll() { +void Console::_scroll() { u16 i; while (_cursorY > 24) { for (i = 0; i < 24 * 80; ++i) @@ -78,7 +78,7 @@ void AkariConsoleSubsystem::_scroll() { } } -void AkariConsoleSubsystem::_shiftCursor() { +void Console::_shiftCursor() { if (++_cursorX >= 80) { _cursorX = 0; ++_cursorY; @@ -87,7 +87,7 @@ void AkariConsoleSubsystem::_shiftCursor() { _updateCursor(); } -void AkariConsoleSubsystem::_shiftCursorTab() { +void Console::_shiftCursorTab() { if ((_cursorX = _cursorX - (_cursorX % 8) + 8) >= 80) { _cursorX = 0; ++_cursorY; @@ -96,14 +96,14 @@ void AkariConsoleSubsystem::_shiftCursorTab() { _updateCursor(); } -void AkariConsoleSubsystem::_shiftCursorNewline() { +void Console::_shiftCursorNewline() { _cursorX = 0; ++_cursorY; _scroll(); _updateCursor(); } -void AkariConsoleSubsystem::_updateCursor() const { +void Console::_updateCursor() const { u16 index = _cursorX + 80 * _cursorY; AkariOutB(PORT_CURSOR_IDX, PORT_CURSOR_MSB_IDX); AkariOutB(PORT_CURSOR_DATA, (index >> 8) & 0xFF); Console.cpp @@ -1,10 +1,10 @@ -#include <AkariDescriptorSubsystem.hpp> -#include <AkariTaskSubsystem.hpp> +#include <Descriptor.hpp> +#include <Tasks.hpp> #include <Akari.hpp> #include <interrupts.hpp> #include <debug.hpp> -AkariDescriptorSubsystem::AkariDescriptorSubsystem(): gdt(0), idt(0), irqt(0) { +Descriptor::Descriptor(): gdt(0), idt(0), irqt(0) { gdt = new GDT(10); gdt->setGate(1, 0, 0xFFFFFFFF, 0, true); // code (CS) gdt->setGate(2, 0, 0xFFFFFFFF, 0, false); // data (SS) @@ -23,12 +23,12 @@ AkariDescriptorSubsystem::AkariDescriptorSubsystem(): gdt(0), idt(0), irqt(0) { irqt = new IRQT(idt); } -u8 AkariDescriptorSubsystem::versionMajor() const { return 0; } -u8 AkariDescriptorSubsystem::versionMinor() const { return 1; } -const char *AkariDescriptorSubsystem::versionManufacturer() const { return "Akari"; } -const char *AkariDescriptorSubsystem::versionProduct() const { return "Akari Descriptor Table Manager"; } +u8 Descriptor::versionMajor() const { return 0; } +u8 Descriptor::versionMinor() const { return 1; } +const char *Descriptor::versionManufacturer() const { return "Akari"; } +const char *Descriptor::versionProduct() const { return "Akari Descriptor Table Manager"; } -AkariDescriptorSubsystem::GDT::GDT(u32 n): _entryCount(n), _entries(0) { +Descriptor::GDT::GDT(u32 n): _entryCount(n), _entries(0) { _entries = new Entry[n]; _pointer.limit = (sizeof(Entry) * n - 1); _pointer.base = (u32)_entries; @@ -36,7 +36,7 @@ AkariDescriptorSubsystem::GDT::GDT(u32 n): _entryCount(n), _entries(0) { setGate(0, 0, 0, 0, 0); } -void AkariDescriptorSubsystem::GDT::setGateFields(s32 num, u32 base, u32 limit, u8 access, u8 granularity) { +void Descriptor::GDT::setGateFields(s32 num, u32 base, u32 limit, u8 access, u8 granularity) { ASSERT(num >= 0 && num < (s32)_entryCount); _entries[num].base_low = (base & 0xFFFF); @@ -49,16 +49,16 @@ void AkariDescriptorSubsystem::GDT::setGateFields(s32 num, u32 base, u32 limit, _entries[num].access = access; } -void AkariDescriptorSubsystem::GDT::setGate(s32 num, u32 base, u32 limit, u8 dpl, bool code) { +void Descriptor::GDT::setGate(s32 num, u32 base, u32 limit, u8 dpl, bool code) { // access flag is like 0b1xx1yyyy, where yyyy = code?0xA:0x2 (just 'cause), and xx=DPL. setGateFields(num, base, limit, (code ? 0xA : 0x2) | (dpl << 5) | (0x9 << 4), 0xCF); } -void AkariDescriptorSubsystem::GDT::clearGate(s32 num) { +void Descriptor::GDT::clearGate(s32 num) { setGateFields(num, 0, 0, 0, 0); } -void AkariDescriptorSubsystem::GDT::writeTSS(s32 num, u16 ss0, u32 esp0) { +void Descriptor::GDT::writeTSS(s32 num, u16 ss0, u32 esp0) { u32 base = (u32)&_tssEntry; u32 limit = base + sizeof(TSSEntry); @@ -78,7 +78,7 @@ void AkariDescriptorSubsystem::GDT::writeTSS(s32 num, u16 ss0, u32 esp0) { setGateFields(num, base, limit, 0xE9, 0x00); } -void AkariDescriptorSubsystem::GDT::flush() { +void Descriptor::GDT::flush() { __asm__ __volatile__(" \ movl %0, %%eax; \ lgdt (%%eax); \ @@ -92,19 +92,19 @@ void AkariDescriptorSubsystem::GDT::flush() { .flush:" : : "r" ((u32)&_pointer) : "eax"); } -void AkariDescriptorSubsystem::GDT::flushTSS(s32 num) { +void Descriptor::GDT::flushTSS(s32 num) { __asm__ __volatile__("ltr %%ax" : : "a" ((num * 8) + 0x3)); } -void AkariDescriptorSubsystem::GDT::setTSSStack(u32 addr) { +void Descriptor::GDT::setTSSStack(u32 addr) { _tssEntry.esp0 = addr; } -void AkariDescriptorSubsystem::GDT::setTSSIOMap(u8 *const &iomap) { +void Descriptor::GDT::setTSSIOMap(u8 *const &iomap) { POSIX::memcpy(_tssEntry.iomap, iomap, 32); } -AkariDescriptorSubsystem::IDT::IDT() { +Descriptor::IDT::IDT() { for (u16 i = 0; i < 0x100; ++i) _routines[i] = 0; @@ -129,22 +129,22 @@ AkariDescriptorSubsystem::IDT::IDT() { __asm__ __volatile__("lidt %0" : : "m" (_pointer)); } -void AkariDescriptorSubsystem::IDT::installHandler(u8 isr, isr_handler_func_t callback) { +void Descriptor::IDT::installHandler(u8 isr, isr_handler_func_t callback) { ASSERT(isr >= 0 && isr <= 0xFF); _routines[isr] = callback; } -void AkariDescriptorSubsystem::IDT::clearHandler(u8 isr) { +void Descriptor::IDT::clearHandler(u8 isr) { installHandler(isr, 0); } -void *AkariDescriptorSubsystem::IDT::callHandler(u8 isr, struct modeswitch_registers *regs) { +void *Descriptor::IDT::callHandler(u8 isr, struct modeswitch_registers *regs) { if (_routines[isr]) return _routines[isr](regs); return 0; } -void AkariDescriptorSubsystem::IDT::setGate(u8 idt, void (*callback)(), u16 isrSegment, u8 flags) { +void Descriptor::IDT::setGate(u8 idt, void (*callback)(), u16 isrSegment, u8 flags) { _entries[idt].offset_low = (u32)callback & 0xFFFF; _entries[idt].selector = isrSegment; _entries[idt]._always_0 = 0; @@ -152,7 +152,7 @@ void AkariDescriptorSubsystem::IDT::setGate(u8 idt, void (*callback)(), u16 isrS _entries[idt].offset_high = ((u32)callback >> 16) & 0xFFFF; } -AkariDescriptorSubsystem::IRQT::IRQT(IDT *idt): _idt(idt) { +Descriptor::IRQT::IRQT(IDT *idt): _idt(idt) { AkariOutB(0x20, 0x11); AkariOutB(0xA0, 0x11); AkariOutB(0x21, 0x20); @@ -175,18 +175,18 @@ AkariDescriptorSubsystem::IRQT::IRQT(IDT *idt): _idt(idt) { _routines[i] = 0; } -void AkariDescriptorSubsystem::IRQT::installHandler(u8 irq, irq_handler_func_t callback) { +void Descriptor::IRQT::installHandler(u8 irq, irq_handler_func_t callback) { // you can't set IRQ 0 (timer) here - it's done manually. see interrupts.s ASSERT(irq >= 1 && irq <= 0x0f); _routines[irq] = callback; } -void AkariDescriptorSubsystem::IRQT::clearHandler(u8 irq) { +void Descriptor::IRQT::clearHandler(u8 irq) { installHandler(irq, 0); } -void *AkariDescriptorSubsystem::IRQT::callHandler(u8 irq, struct modeswitch_registers *regs) { - AkariTaskSubsystem::Task *iter = Akari->Task->start; +void *Descriptor::IRQT::callHandler(u8 irq, struct modeswitch_registers *regs) { + Tasks::Task *iter = Akari->tasks->start; while (iter) { if (iter->irqListen == irq) { iter->irqListenHits++; @@ -197,7 +197,7 @@ void *AkariDescriptorSubsystem::IRQT::callHandler(u8 irq, struct modeswitch_regi // Looks like it's their turn. We append the current `iter` to the linked // list made of ATS#priorityStart and the Task's own priorityNext's. - AkariTaskSubsystem::Task **append = &Akari->Task->priorityStart; + Tasks::Task **append = &Akari->tasks->priorityStart; while (*append) append = &(*append)->priorityNext; *append = iter; @@ -207,15 +207,15 @@ void *AkariDescriptorSubsystem::IRQT::callHandler(u8 irq, struct modeswitch_regi } // If there's a priority, switch to it immediately. Crap. What do we do about handlers?! - if (Akari->Task->priorityStart) { - iter = Akari->Task->priorityStart; - Akari->Task->priorityStart = iter->priorityNext; + if (Akari->tasks->priorityStart) { + iter = Akari->tasks->priorityStart; + Akari->tasks->priorityStart = iter->priorityNext; iter->priorityNext = 0; // Task switch! - Akari->Task->saveRegisterToTask(Akari->Task->current, regs); - Akari->Task->current = iter; - return Akari->Task->assignInternalTask(Akari->Task->current); + Akari->tasks->saveRegisterToTask(Akari->tasks->current, regs); + Akari->tasks->current = iter; + return Akari->tasks->assignInternalTask(Akari->tasks->current); } Descriptor.cpp @@ -1,9 +1,9 @@ -#include <AkariMemorySubsystem.hpp> +#include <Memory.hpp> #include <Akari.hpp> #include <POSIX.hpp> #include <debug.hpp> #include <entry.hpp> -#include <memory.hpp> +#include <physmem.hpp> // Index into _frames, and the bit offset within a single entry #define INDEX_BIT(n) ((n)/(8*4)) @@ -18,17 +18,17 @@ // minimum size of a heap #define HEAP_MIN_SIZE 0x500000 -AkariMemorySubsystem::AkariMemorySubsystem(u32 upperMemory): +Memory::Memory(u32 upperMemory): _upperMemory(upperMemory), _placementAddress(0), _frames(0), _frameCount(0), _heap(0), _kernelDirectory(0), _activeDirectory(0) { } -u8 AkariMemorySubsystem::versionMajor() const { return 0; } -u8 AkariMemorySubsystem::versionMinor() const { return 1; } -const char *AkariMemorySubsystem::versionManufacturer() const { return "Akari"; } -const char *AkariMemorySubsystem::versionProduct() const { return "Akari Memory Heap"; } +u8 Memory::versionMajor() const { return 0; } +u8 Memory::versionMinor() const { return 1; } +const char *Memory::versionManufacturer() const { return "Akari"; } +const char *Memory::versionProduct() const { return "Akari Memory Heap"; } -void AkariMemorySubsystem::setPlacementMode(u32 addr) { +void Memory::setPlacementMode(u32 addr) { ASSERT(!_placementAddress); _placementAddress = addr; @@ -44,7 +44,7 @@ void AkariMemorySubsystem::setPlacementMode(u32 addr) { // temp debug flag only, set to true if you want the kheap to be writeable from usermode! #define KERNEL_HEAP_PROMISC true -void AkariMemorySubsystem::setPaging(bool mode) { +void Memory::setPaging(bool mode) { ASSERT(mode); // TODO support turning paging off [if ever required?! who knows! :)] _frameCount = (0x100000 + _upperMemory * 1024) / 0x1000; @@ -65,7 +65,7 @@ void AkariMemorySubsystem::setPaging(bool mode) { for (u32 i = KHEAP_START; i < KHEAP_START + KHEAP_INITIAL_SIZE; i += 0x1000) _kernelDirectory->getPage(i, true)->allocAnyFrame(false, KERNEL_HEAP_PROMISC); - Akari->Descriptor->idt->installHandler(14, this->PageFault); + Akari->descriptor->idt->installHandler(14, this->PageFault); switchPageDirectory(_kernelDirectory); _heap = new Heap(KHEAP_START, KHEAP_START + KHEAP_INITIAL_SIZE, 0xCFFFF000, false, !(KERNEL_HEAP_PROMISC)); @@ -75,7 +75,7 @@ void AkariMemorySubsystem::setPaging(bool mode) { // SwitchPageDirectory(_activeDirectory); } -void *AkariMemorySubsystem::alloc(u32 n, u32 *phys) { +void *Memory::alloc(u32 n, u32 *phys) { if (!_placementAddress) { ASSERT(_heap); void *addr = _heap->alloc(n); @@ -97,7 +97,7 @@ void *AkariMemorySubsystem::alloc(u32 n, u32 *phys) { return (void *)addr; } -void *AkariMemorySubsystem::allocAligned(u32 n, u32 *phys) { +void *Memory::allocAligned(u32 n, u32 *phys) { if (!_placementAddress) { ASSERT(_heap); void *addr = _heap->allocAligned(n); @@ -122,17 +122,17 @@ void *AkariMemorySubsystem::allocAligned(u32 n, u32 *phys) { return (void *)addr; } -void AkariMemorySubsystem::free(void *p) { +void Memory::free(void *p) { if (!_placementAddress) { ASSERT(_heap); // AkariPanic("implement Free() for heaps"); return; } - AkariPanic("AkariMemorySubsystem: tried to Free() in placement mode"); + AkariPanic("Memory: tried to Free() in placement mode"); } -void *AkariMemorySubsystem::PageFault(struct modeswitch_registers *r) { +void *Memory::PageFault(struct modeswitch_registers *r) { u32 faultingAddress; __asm__ __volatile__("mov %%cr2, %0" : "=r" (faultingAddress)); @@ -142,16 +142,16 @@ void *AkariMemorySubsystem::PageFault(struct modeswitch_registers *r) { bool reserved = r->callback.err_code & 0x8; bool insFetch = r->callback.err_code & 0x10; - Akari->Console->putString("\nPage fault!\n"); - if (notPresent) Akari->Console->putString(" * Page wasn't present.\n"); - if (writeOp) Akari->Console->putString(" * Write operation.\n"); - if (userMode) Akari->Console->putString(" * From user-mode.\n"); - if (reserved) Akari->Console->putString(" * Clobbered reserved bits in page.\n"); - if (insFetch) Akari->Console->putString(" * On instruction fetch.\n"); + Akari->console->putString("\nPage fault!\n"); + if (notPresent) Akari->console->putString(" * Page wasn't present.\n"); + if (writeOp) Akari->console->putString(" * Write operation.\n"); + if (userMode) Akari->console->putString(" * From user-mode.\n"); + if (reserved) Akari->console->putString(" * Clobbered reserved bits in page.\n"); + if (insFetch) Akari->console->putString(" * On instruction fetch.\n"); - Akari->Console->putString("Address: 0x"); - Akari->Console->putInt(faultingAddress, 16); - Akari->Console->putChar('\n'); + Akari->console->putString("Address: 0x"); + Akari->console->putInt(faultingAddress, 16); + Akari->console->putChar('\n'); while (1) __asm__ __volatile__("hlt"); @@ -159,7 +159,7 @@ void *AkariMemorySubsystem::PageFault(struct modeswitch_registers *r) { return 0; } -void AkariMemorySubsystem::switchPageDirectory(PageDirectory *dir) { +void Memory::switchPageDirectory(PageDirectory *dir) { u32 phys = dir->physicalAddr; _activeDirectory = dir; @@ -175,28 +175,28 @@ void AkariMemorySubsystem::switchPageDirectory(PageDirectory *dir) { // XXX do we always necessarily want to use $8 with ljmp here? } -void AkariMemorySubsystem::setFrame(u32 addr) { +void Memory::setFrame(u32 addr) { u32 frame = addr / 0x1000; u32 idx = INDEX_BIT(frame), off = OFFSET_BIT(frame); ASSERT(idx < INDEX_BIT(_frameCount)); _frames[idx] |= (1 << off); } -void AkariMemorySubsystem::clearFrame(u32 addr) { +void Memory::clearFrame(u32 addr) { u32 frame = addr / 0x1000; u32 idx = INDEX_BIT(frame), off = OFFSET_BIT(frame); ASSERT(idx < INDEX_BIT(_frameCount)); _frames[idx] &= ~(1 << off); } -bool AkariMemorySubsystem::testFrame(u32 addr) const { +bool Memory::testFrame(u32 addr) const { u32 frame = addr / 0x1000; u32 idx = INDEX_BIT(frame), off = OFFSET_BIT(frame); ASSERT(idx < INDEX_BIT(_frameCount)); return (_frames[idx] & (1 << off)); } -u32 AkariMemorySubsystem::freeFrame() const { +u32 Memory::freeFrame() const { for (u32 i = 0; i < INDEX_BIT(_frameCount); ++i) if (_frames[i] != 0xFFFFFFFF) { for (u32 j = 0; j < 32; ++j) @@ -210,7 +210,7 @@ u32 AkariMemorySubsystem::freeFrame() const { // Heap -AkariMemorySubsystem::Heap::Heap(u32 start, u32 end, u32 max, bool supervisor, bool readonly): +Memory::Heap::Heap(u32 start, u32 end, u32 max, bool supervisor, bool readonly): _index((Entry *)start, HEAP_INDEX_SIZE, IndexSort), _start(start), _end(end), _max(max), _supervisor(supervisor), _readonly(readonly) { @@ -231,7 +231,7 @@ _start(start), _end(end), _max(max), _supervisor(supervisor), _readonly(readonly ASSERT(_index[0].isHole); } -void *AkariMemorySubsystem::Heap::alloc(u32 n) { +void *Memory::Heap::alloc(u32 n) { s32 it = smallestHole(n); ASSERT(it >= 0); // TODO: resize instead @@ -253,7 +253,7 @@ void *AkariMemorySubsystem::Heap::alloc(u32 n) { return (void *)dataStart; } -void *AkariMemorySubsystem::Heap::allocAligned(u32 n) { +void *Memory::Heap::allocAligned(u32 n) { s32 it = smallestAlignedHole(n); ASSERT(it >= 0); // TODO: resize instead @@ -291,15 +291,15 @@ void *AkariMemorySubsystem::Heap::allocAligned(u32 n) { return (void *)dataStart; } -AkariMemorySubsystem::Heap::Entry::Entry(u32 start, u32 size, bool isHole): +Memory::Heap::Entry::Entry(u32 start, u32 size, bool isHole): start(start), size(size), isHole(isHole) { } -bool AkariMemorySubsystem::Heap::IndexSort(const Entry &a, const Entry &b) { +bool Memory::Heap::IndexSort(const Entry &a, const Entry &b) { return a.size < b.size; } -s32 AkariMemorySubsystem::Heap::smallestHole(u32 n) const { +s32 Memory::Heap::smallestHole(u32 n) const { u32 it = 0; ASSERT(_index.size() > 0); @@ -317,7 +317,7 @@ s32 AkariMemorySubsystem::Heap::smallestHole(u32 n) const { return -1; } -s32 AkariMemorySubsystem::Heap::smallestAlignedHole(u32 n) const { +s32 Memory::Heap::smallestAlignedHole(u32 n) const { u32 it = 0; while (it < _index.size()) { const Entry &entry = _index[it]; @@ -343,21 +343,21 @@ s32 AkariMemorySubsystem::Heap::smallestAlignedHole(u32 n) const { // Page -void AkariMemorySubsystem::Page::allocAnyFrame(bool kernel, bool writeable) { +void Memory::Page::allocAnyFrame(bool kernel, bool writeable) { ASSERT(!pageAddress); - u32 addr = Akari->Memory->freeFrame(); - Akari->Memory->setFrame(addr); + u32 addr = Akari->memory->freeFrame(); + Akari->memory->setFrame(addr); present = true; readwrite = writeable; user = !kernel; pageAddress = addr / 0x1000; } -void AkariMemorySubsystem::Page::allocFrame(u32 addr, bool kernel, bool writeable) { +void Memory::Page::allocFrame(u32 addr, bool kernel, bool writeable) { ASSERT(!pageAddress); - Akari->Memory->setFrame(addr); + Akari->memory->setFrame(addr); present = true; readwrite = writeable; user = !kernel; @@ -366,13 +366,13 @@ void AkariMemorySubsystem::Page::allocFrame(u32 addr, bool kernel, bool writeabl // PageTable -AkariMemorySubsystem::PageTable *AkariMemorySubsystem::PageTable::Allocate(u32 *phys) { - PageTable *table = (PageTable *)Akari->Memory->allocAligned(sizeof(PageTable), phys); +Memory::PageTable *Memory::PageTable::Allocate(u32 *phys) { + PageTable *table = (PageTable *)Akari->memory->allocAligned(sizeof(PageTable), phys); POSIX::memset(table, 0, sizeof(PageTable)); return table; } -AkariMemorySubsystem::PageTable *AkariMemorySubsystem::PageTable::clone(u32 *phys) const { +Memory::PageTable *Memory::PageTable::clone(u32 *phys) const { // TODO: review this PageTable *t = PageTable::Allocate(phys); @@ -397,10 +397,10 @@ AkariMemorySubsystem::PageTable *AkariMemorySubsystem::PageTable::clone(u32 *phy // PageDirectory -AkariMemorySubsystem::PageDirectory *AkariMemorySubsystem::PageDirectory::Allocate() { +Memory::PageDirectory *Memory::PageDirectory::Allocate() { u32 phys; - PageDirectory *dir = (PageDirectory *)Akari->Memory->allocAligned(sizeof(PageDirectory), &phys); + PageDirectory *dir = (PageDirectory *)Akari->memory->allocAligned(sizeof(PageDirectory), &phys); POSIX::memset(dir, 0, sizeof(PageDirectory)); u32 off = (u32)dir->tablePhysicals - (u32)dir; dir->physicalAddr = phys + off; // check above @@ -408,7 +408,7 @@ AkariMemorySubsystem::PageDirectory *AkariMemorySubsystem::PageDirectory::Alloca return dir; } -AkariMemorySubsystem::Page *AkariMemorySubsystem::PageDirectory::getPage(u32 addr, bool make) { +Memory::Page *Memory::PageDirectory::getPage(u32 addr, bool make) { addr /= 0x1000; u32 idx = addr / 1024, entry = addr % 1024; @@ -424,14 +424,14 @@ AkariMemorySubsystem::Page *AkariMemorySubsystem::PageDirectory::getPage(u32 add return 0; } -AkariMemorySubsystem::PageDirectory *AkariMemorySubsystem::PageDirectory::clone() const { +Memory::PageDirectory *Memory::PageDirectory::clone() const { // TODO: review this code PageDirectory *d = PageDirectory::Allocate(); for (u32 i = 0; i < 1024; ++i) { if (!tables[i]) continue; - if (Akari->Memory->_kernelDirectory->tables[i] == tables[i]) { + if (Akari->memory->_kernelDirectory->tables[i] == tables[i]) { // kernel has this table, so just link it d->tables[i] = tables[i]; d->tablePhysicals[i] = tablePhysicals[i]; Memory.cpp @@ -1,7 +1,7 @@ -#include <AkariSubsystem.hpp> +#include <Subsystem.hpp> -AkariSubsystem::AkariSubsystem() +Subsystem::Subsystem() { } -AkariSubsystem::~AkariSubsystem() +Subsystem::~Subsystem() { } Subsystem.cpp @@ -1,9 +1,9 @@ -#include <AkariSyscallSubsystem.hpp> +#include <Syscall.hpp> #include <Akari.hpp> #include <UserCalls.hpp> -AkariSyscallSubsystem::AkariSyscallSubsystem(): _syscalls_assigned(0) { - Akari->Descriptor->idt->installHandler(0x80, &AkariSyscallSubsystem::_handler); +Syscall::Syscall(): _syscalls_assigned(0) { + Akari->descriptor->idt->installHandler(0x80, &Syscall::_handler); addSyscall(0, (void *)&User::putc); addSyscall(1, (void *)&User::puts); @@ -17,37 +17,37 @@ AkariSyscallSubsystem::AkariSyscallSubsystem(): _syscalls_assigned(0) { addSyscall(9, (void *)&User::exit); } -u8 AkariSyscallSubsystem::versionMajor() const { return 0; } -u8 AkariSyscallSubsystem::versionMinor() const { return 1; } -const char *AkariSyscallSubsystem::versionManufacturer() const { return "Akari"; } -const char *AkariSyscallSubsystem::versionProduct() const { return "Akari Syscall"; } +u8 Syscall::versionMajor() const { return 0; } +u8 Syscall::versionMinor() const { return 1; } +const char *Syscall::versionManufacturer() const { return "Akari"; } +const char *Syscall::versionProduct() const { return "Akari Syscall"; } -void AkariSyscallSubsystem::addSyscall(u16 num, void *fn) { +void Syscall::addSyscall(u16 num, void *fn) { _syscalls[num] = fn; } -void AkariSyscallSubsystem::returnToTask(AkariTaskSubsystem::Task *task) { +void Syscall::returnToTask(Tasks::Task *task) { _returnTask = task; } -void AkariSyscallSubsystem::returnToNextTask() { - AkariTaskSubsystem::Task *nextTask = Akari->Task->getNextTask(); - if (nextTask == Akari->Task->current) { +void Syscall::returnToNextTask() { + Tasks::Task *nextTask = Akari->tasks->getNextTask(); + if (nextTask == Akari->tasks->current) { AkariPanic("TODO: let no 'active' processes being running. i.e. have the ukernel HLT or similar."); } returnToTask(nextTask); } -void *AkariSyscallSubsystem::_handler(struct modeswitch_registers *regs) { +void *Syscall::_handler(struct modeswitch_registers *regs) { if (regs->callback.eax >= AKARI_SYSCALL_MAXCALLS) AkariPanic("System call greater than maximum requested. TODO: kill requesting process."); - if (!Akari->Syscall->_syscalls[regs->callback.eax]) + if (!Akari->syscall->_syscalls[regs->callback.eax]) AkariPanic("Non-existing system call requested."); - Akari->Syscall->_returnTask = 0; + Akari->syscall->_returnTask = 0; - void *call = Akari->Syscall->_syscalls[regs->callback.eax]; + void *call = Akari->syscall->_syscalls[regs->callback.eax]; int ret; asm volatile(" \ push %1; \ @@ -68,10 +68,10 @@ void *AkariSyscallSubsystem::_handler(struct modeswitch_registers *regs) { regs->callback.eax = ret; - if (Akari->Syscall->_returnTask) { - Akari->Task->saveRegisterToTask(Akari->Task->current, regs); - Akari->Task->current = Akari->Syscall->_returnTask; - return Akari->Task->assignInternalTask(Akari->Task->current); + if (Akari->syscall->_returnTask) { + Akari->tasks->saveRegisterToTask(Akari->tasks->current, regs); + Akari->tasks->current = Akari->syscall->_returnTask; + return Akari->tasks->assignInternalTask(Akari->tasks->current); } return regs; Syscall.cpp @@ -1,15 +1,15 @@ -#include <AkariTimerSubsystem.hpp> +#include <Timer.hpp> #include <arch.hpp> -AkariTimerSubsystem::AkariTimerSubsystem() +Timer::Timer() { } -u8 AkariTimerSubsystem::versionMajor() const { return 0; } -u8 AkariTimerSubsystem::versionMinor() const { return 1; } -const char *AkariTimerSubsystem::versionManufacturer() const { return "Akari"; } -const char *AkariTimerSubsystem::versionProduct() const { return "Akari Timer Manager"; } +u8 Timer::versionMajor() const { return 0; } +u8 Timer::versionMinor() const { return 1; } +const char *Timer::versionManufacturer() const { return "Akari"; } +const char *Timer::versionProduct() const { return "Akari Timer Manager"; } -void AkariTimerSubsystem::setTimer(u16 hz) { +void Timer::setTimer(u16 hz) { u16 r = 0x1234dc / hz; AkariOutB(0x43, 0x36); // 0b00110110; not BCD, square, LSB+MSB, c0 AkariOutB(0x40, r & 0xFF); Timer.cpp @@ -92,7 +92,7 @@ void KeyboardProcess() { u8 scancode = AkariInB(0x60); while (1) { - Akari->Console->putString("This is the Captain speaking."); + Akari->console->putString("This is the Captain speaking."); if (scancode & 0x80) { // release scancode &= ~0x80; TmpKb.cpp @@ -4,34 +4,34 @@ namespace User { void putc(char c) { - Akari->Console->putChar(c); + Akari->console->putChar(c); } void puts(const char *s) { - Akari->Console->putString(s); + Akari->console->putString(s); } void putl(u32 n, u8 base) { - Akari->Console->putInt(n, base); + Akari->console->putInt(n, base); } u32 getProcessId() { - return Akari->Task->current->id; + return Akari->tasks->current->id; } void irqWait() { - if (Akari->Task->current->irqListenHits == 0) { - Akari->Task->current->irqWaiting = true; + if (Akari->tasks->current->irqListenHits == 0) { + Akari->tasks->current->irqWaiting = true; - Akari->Syscall->returnToNextTask(); + Akari->syscall->returnToNextTask(); return; } - Akari->Task->current->irqListenHits--; + Akari->tasks->current->irqListenHits--; } void irqListen(u32 irq) { - Akari->Task->current->irqListen = irq; - Akari->Task->current->irqListenHits = 0; + Akari->tasks->current->irqListen = irq; + Akari->tasks->current->irqListenHits = 0; } @@ -44,45 +44,45 @@ namespace User { } bool registerName(const char *name) { - if (Akari->Task->registeredTasks->hasKey(name)) + if (Akari->tasks->registeredTasks->hasKey(name)) return false; - (*Akari->Task->registeredTasks)[name] = Akari->Task->current; - Akari->Task->current->registeredName = name; + (*Akari->tasks->registeredTasks)[name] = Akari->tasks->current; + Akari->tasks->current->registeredName = name; return true; } bool registerNode(const char *name) { - if (!Akari->Task->current->registeredName) { + if (!Akari->tasks->current->registeredName) { // TODO: just kill the process, don't kill the system. // TODO: is this correct behaviour? Or could we have registered nodes // on no particular name? Why not?.. think about it. AkariPanic("name not registered - cannot register node"); } - if (Akari->Task->current->nodesByName->hasKey(name)) { + if (Akari->tasks->current->nodesByName->hasKey(name)) { AkariPanic("node already registered - cannot register atop it"); } - AkariTaskSubsystem::Task::Node *node = new AkariTaskSubsystem::Task::Node(); + Tasks::Task::Node *node = new Tasks::Task::Node(); - (*Akari->Task->current->nodesByName)[name] = node; + (*Akari->tasks->current->nodesByName)[name] = node; return true; } void exit() { - Akari->Syscall->returnToNextTask(); - // Find the Task* which refers to Akari->Task->current, and get it to skip it. - AkariTaskSubsystem::Task **scanner = &Akari->Task->start; - while (*scanner != Akari->Task->current) { + Akari->syscall->returnToNextTask(); + // Find the Task* which refers to Akari->tasks->current, and get it to skip it. + Tasks::Task **scanner = &Akari->tasks->start; + while (*scanner != Akari->tasks->current) { scanner = &(*scanner)->next; } - Akari->Console->putString("exit(): 0x"); - Akari->Console->putInt((u32)*scanner, 16); - Akari->Console->putString(" -> 0x"); - Akari->Console->putInt((u32)(*scanner)->next, 16); - Akari->Console->putString("\n"); + Akari->console->putString("exit(): 0x"); + Akari->console->putInt((u32)*scanner, 16); + Akari->console->putString(" -> 0x"); + Akari->console->putInt((u32)(*scanner)->next, 16); + Akari->console->putString("\n"); *scanner = (*scanner)->next; // Gone! XXX what happens when the last task exists!? Everything probably goes to hell ... UserCalls.cpp @@ -42,7 +42,7 @@ return a; \ } -// Here we define the user-mode functions, matching them to the number in the _syscalls array (see AkariSyscallSubsystem). +// Here we define the user-mode functions, matching them to the number in the _syscalls array (see Syscall). DEFN_SYSCALL1(putc, 0, char); DEFN_SYSCALL1(puts, 1, const char *); UserGates.cpp @@ -28,14 +28,14 @@ void __cxa_pure_virtual() { void *operator new(size_t n) { ASSERT(Akari); - ASSERT(Akari->Memory); - return Akari->Memory->alloc(n); + ASSERT(Akari->memory); + return Akari->memory->alloc(n); } void *operator new[](size_t n) { ASSERT(Akari); - ASSERT(Akari->Memory); - return Akari->Memory->alloc(n); + ASSERT(Akari->memory); + return Akari->memory->alloc(n); } void *operator new(size_t, void *p) { @@ -44,13 +44,13 @@ void *operator new(size_t, void *p) { void operator delete(void *p) { ASSERT(Akari); - ASSERT(Akari->Memory); - return Akari->Memory->free(p); + ASSERT(Akari->memory); + return Akari->memory->free(p); } void operator delete[](void *p) { // These assertions seem quite wasteful. ASSERT(Akari); - ASSERT(Akari->Memory); - return Akari->Memory->free(p); + ASSERT(Akari->memory); + return Akari->memory->free(p); } arch.cpp @@ -21,23 +21,23 @@ void AkariEntry() { if ((AkariMultiboot->flags & 0x41) != 0x41) AkariPanic("Akari: MULTIBOOT hasn't given us enough information about memory."); - Akari = AkariKernel::Construct((u32)&__kend, AkariMultiboot->mem_upper); + Akari = Kernel::Construct((u32)&__kend, AkariMultiboot->mem_upper); // these can only work if Akari = an AkariKernel, since `new' calls Akari->... // how could we integrate these with construction in AkariKernel::Construct // without just doing it all by using placement new with kernel->Alloc? // (which is lame) - Akari->Console = new AkariConsoleSubsystem(); - Akari->Descriptor = new AkariDescriptorSubsystem(); - Akari->Timer = new AkariTimerSubsystem(); - Akari->Task = new AkariTaskSubsystem(); - Akari->Syscall = new AkariSyscallSubsystem(); - - Akari->Timer->setTimer(100); - Akari->Memory->setPaging(true); + Akari->console = new Console(); + Akari->descriptor = new Descriptor(); + Akari->timer = new Timer(); + Akari->tasks = new Tasks(); + Akari->syscall = new Syscall(); + + Akari->timer->setTimer(100); + Akari->memory->setPaging(true); // Give ourselves a normal stack. (n.b. this is from kernel heap!) - void *IdleTaskStack = Akari->Memory->allocAligned(IDLE_STACK_SIZE); + void *IdleTaskStack = Akari->memory->allocAligned(IDLE_STACK_SIZE); // do we still need to flush the TLB? __asm__ __volatile__("\ mov %%cr3, %%eax; \ @@ -50,38 +50,38 @@ void AkariEntry() { } static void AkariEntryCont() { - ASSERT(Akari->Memory->_activeDirectory == Akari->Memory->_kernelDirectory); + ASSERT(Akari->memory->_activeDirectory == Akari->memory->_kernelDirectory); for (u32 i = UKERNEL_STACK_POS; i >= UKERNEL_STACK_POS - UKERNEL_STACK_SIZE; i -= 0x1000) - Akari->Memory->_activeDirectory->getPage(i, true)->allocAnyFrame(false, true); + Akari->memory->_activeDirectory->getPage(i, true)->allocAnyFrame(false, true); - AkariTaskSubsystem::Task *base = AkariTaskSubsystem::Task::BootstrapInitialTask( - 3, Akari->Memory->_kernelDirectory); - Akari->Task->start = Akari->Task->current = base; + Tasks::Task *base = Tasks::Task::BootstrapInitialTask( + 3, Akari->memory->_kernelDirectory); + Akari->tasks->start = Akari->tasks->current = base; - Akari->Descriptor->gdt->setTSSStack(base->utks + sizeof(struct modeswitch_registers)); - Akari->Descriptor->gdt->setTSSIOMap(base->iomap); + Akari->descriptor->gdt->setTSSStack(base->utks + sizeof(struct modeswitch_registers)); + Akari->descriptor->gdt->setTSSIOMap(base->iomap); // Idle task - AkariTaskSubsystem::Task *idle = AkariTaskSubsystem::Task::CreateTask( - (u32)&IdleProcess, 0, true, 0, Akari->Memory->_kernelDirectory); - Akari->Task->current->next = idle; + Tasks::Task *idle = Tasks::Task::CreateTask( + (u32)&IdleProcess, 0, true, 0, Akari->memory->_kernelDirectory); + Akari->tasks->current->next = idle; // Keyboard driver task - AkariTaskSubsystem::Task *kbdriver = AkariTaskSubsystem::Task::CreateTask( - (u32)&KeyboardProcess, 1, true, 0, Akari->Memory->_kernelDirectory); + Tasks::Task *kbdriver = Tasks::Task::CreateTask( + (u32)&KeyboardProcess, 1, true, 0, Akari->memory->_kernelDirectory); kbdriver->setIOMap(0x60, true); kbdriver->setIOMap(0x64, true); idle->next = kbdriver; // Hello shell! - AkariTaskSubsystem::Task *shell = AkariTaskSubsystem::Task::CreateTask( - (u32)&ShellProcess, 0, true, 0, Akari->Memory->_kernelDirectory); + Tasks::Task *shell = Tasks::Task::CreateTask( + (u32)&ShellProcess, 0, true, 0, Akari->memory->_kernelDirectory); kbdriver->next = shell; // Now we need our own directory! BootstrapTask should've been nice enough to make us one anyway. - Akari->Memory->switchPageDirectory(base->pageDir); + Akari->memory->switchPageDirectory(base->pageDir); - AkariTaskSubsystem::SwitchRing(3, 0); // switches to ring 3, uses IOPL 0 (no I/O access unless iomap gives it) and enables interrupts. + Tasks::SwitchRing(3, 0); // switches to ring 3, uses IOPL 0 (no I/O access unless iomap gives it) and enables interrupts. // We have a proper (kernel-mode) idle task we spawn above that hlts. syscall_exit(); @@ -89,7 +89,7 @@ static void AkariEntryCont() { // Returns how much the stack needs to be shifted. void *AkariMicrokernel(struct modeswitch_registers *r) { - Akari->Task->saveRegisterToTask(Akari->Task->current, r); - Akari->Task->cycleTask(); - return Akari->Task->assignInternalTask(Akari->Task->current); + Akari->tasks->saveRegisterToTask(Akari->tasks->current, r); + Akari->tasks->cycleTask(); + return Akari->tasks->assignInternalTask(Akari->tasks->current); } entry.cpp @@ -1,35 +1,35 @@ #ifndef __AKARI_HPP__ #define __AKARI_HPP__ -#include <AkariMemorySubsystem.hpp> -#include <AkariConsoleSubsystem.hpp> -#include <AkariDescriptorSubsystem.hpp> -#include <AkariTimerSubsystem.hpp> -#include <AkariTaskSubsystem.hpp> -#include <AkariSyscallSubsystem.hpp> +#include <Memory.hpp> +#include <Console.hpp> +#include <Descriptor.hpp> +#include <Timer.hpp> +#include <Tasks.hpp> +#include <Syscall.hpp> /** * The base class for the kernel services. */ -class AkariKernel { +class Kernel { public: - static AkariKernel *Construct(u32, u32); + static Kernel *Construct(u32, u32); - // TODO: linked list of AkariSubsystems so we can iterate them generically. + // TODO: linked list of Subsystems so we can iterate them generically. - AkariMemorySubsystem *Memory; - AkariConsoleSubsystem *Console; - AkariDescriptorSubsystem *Descriptor; - AkariTimerSubsystem *Timer; - AkariTaskSubsystem *Task; - AkariSyscallSubsystem *Syscall; + Memory *memory; + Console *console; + Descriptor *descriptor; + Timer *timer; + Tasks *tasks; + Syscall *syscall; protected: - AkariKernel(); + Kernel(); }; -extern AkariKernel *Akari; +extern Kernel *Akari; #endif inc/Akari.hpp @@ -1,12 +1,12 @@ -#ifndef __AKARI_CONSOLE_SUBSYSTEM_HPP__ -#define __AKARI_CONSOLE_SUBSYSTEM_HPP__ +#ifndef __CONSOLE_HPP__ +#define __CONSOLE_HPP__ -#include <AkariSubsystem.hpp> +#include <Subsystem.hpp> // Direct implementation. -class AkariConsoleSubsystem : public AkariSubsystem { +class Console : public Subsystem { public: - AkariConsoleSubsystem(); + Console(); u8 versionMajor() const; u8 versionMinor() const; inc/Console.hpp @@ -1,14 +1,14 @@ -#ifndef __AKARI_DESCRIPTOR_SUBSYSTEM_HPP__ -#define __AKARI_DESCRIPTOR_SUBSYSTEM_HPP__ +#ifndef __DESCRIPTOR_HPP__ +#define __DESCRIPTOR_HPP__ -#include <AkariSubsystem.hpp> +#include <Subsystem.hpp> #include <interrupts.hpp> // the subsystem itself -class AkariDescriptorSubsystem : public AkariSubsystem { +class Descriptor : public Subsystem { public: - AkariDescriptorSubsystem(); + Descriptor(); u8 versionMajor() const; u8 versionMinor() const; inc/Descriptor.hpp @@ -1,12 +1,12 @@ -#ifndef __AKARI_MEMORY_SUBSYSTEM_HPP__ -#define __AKARI_MEMORY_SUBSYSTEM_HPP__ +#ifndef __MEMORY_HPP__ +#define __MEMORY_HPP__ -#include <AkariSubsystem.hpp> +#include <Subsystem.hpp> #include <OrderedArray.hpp> -class AkariMemorySubsystem : public AkariSubsystem { +class Memory : public Subsystem { public: - AkariMemorySubsystem(u32); + Memory(u32); u8 versionMajor() const; u8 versionMinor() const; inc/Memory.hpp @@ -1,12 +1,12 @@ -#ifndef __AKARI_SUBSYSTEM_HPP__ -#define __AKARI_SUBSYSTEM_HPP__ +#ifndef __SUBSYSTEM_HPP__ +#define __SUBSYSTEM_HPP__ #include <arch.hpp> -class AkariSubsystem { +class Subsystem { public: - AkariSubsystem(); - virtual ~AkariSubsystem(); + Subsystem(); + virtual ~Subsystem(); virtual u8 versionMajor() const = 0; virtual u8 versionMinor() const = 0; inc/Subsystem.hpp @@ -1,14 +1,14 @@ -#ifndef __AKARI_SYSCALL_SUBSYSTEM_HPP__ -#define __AKARI_SYSCALL_SUBSYSTEM_HPP__ +#ifndef __SYSCALL_HPP__ +#define __SYSCALL_HPP__ -#include <AkariSubsystem.hpp> -#include <AkariTaskSubsystem.hpp> +#include <Subsystem.hpp> +#include <Tasks.hpp> #define AKARI_SYSCALL_MAXCALLS 256 -class AkariSyscallSubsystem : public AkariSubsystem { +class Syscall : public Subsystem { public: - AkariSyscallSubsystem(); + Syscall(); u8 versionMajor() const; u8 versionMinor() const; @@ -17,7 +17,7 @@ class AkariSyscallSubsystem : public AkariSubsystem { void addSyscall(u16 num, void *fn); - void returnToTask(AkariTaskSubsystem::Task *task); + void returnToTask(Tasks::Task *task); void returnToNextTask(); protected: @@ -26,7 +26,7 @@ class AkariSyscallSubsystem : public AkariSubsystem { void *_syscalls[AKARI_SYSCALL_MAXCALLS]; u16 _syscalls_assigned; - AkariTaskSubsystem::Task *_returnTask; + Tasks::Task *_returnTask; }; #endif inc/Syscall.hpp @@ -1,11 +1,11 @@ -#ifndef __AKARI_TIMER_SUBSYSTEM_HPP__ -#define __AKARI_TIMER_SUBSYSTEM_HPP__ +#ifndef __TIMER_HPP__ +#define __TIMER_HPP__ -#include <AkariSubsystem.hpp> +#include <Subsystem.hpp> -class AkariTimerSubsystem : public AkariSubsystem { +class Timer : public Subsystem { public: - AkariTimerSubsystem(); + Timer(); u8 versionMajor() const; u8 versionMinor() const; inc/Timer.hpp @@ -1,5 +1,5 @@ -#ifndef __MEMORY_HPP__ -#define __MEMORY_HPP__ +#ifndef __PHYSMEM_HPP__ +#define __PHYSMEM_HPP__ extern "C" void AkariCopyFramePhysical(u32 src, u32 dest); inc/physmem.hpp @@ -29,26 +29,26 @@ void *isr_handler(struct modeswitch_registers *r) { ASSERT(r->callback.int_no < 0x20 || r->callback.int_no >= 0x30); // I guess this is right? What other IDTs are there? Hm. - void *resume = Akari->Descriptor->idt->callHandler(r->callback.int_no, r); + void *resume = Akari->descriptor->idt->callHandler(r->callback.int_no, r); if (!resume) { // nothing to call! - Akari->Console->putChar('\n'); - Akari->Console->putString((r->callback.int_no < 32 && isr_messages[r->callback.int_no]) ? isr_messages[r->callback.int_no] : "[Intel reserved]"); - Akari->Console->putString(" exception occured!\n"); + Akari->console->putChar('\n'); + Akari->console->putString((r->callback.int_no < 32 && isr_messages[r->callback.int_no]) ? isr_messages[r->callback.int_no] : "[Intel reserved]"); + Akari->console->putString(" exception occured!\n"); - Akari->Console->putString("EIP: "); - Akari->Console->putInt(r->callback.eip, 16); - Akari->Console->putString(", ESP: "); - Akari->Console->putInt(r->callback.esp, 16); - Akari->Console->putString(", EBP: "); - Akari->Console->putInt(r->callback.ebp, 16); - Akari->Console->putString(", CS: "); - Akari->Console->putInt(r->callback.cs, 16); - Akari->Console->putString(", EFLAGS: "); - Akari->Console->putInt(r->callback.eflags, 16); - Akari->Console->putString(", user ESP (may be garbage): "); - Akari->Console->putInt(r->useresp, 16); - Akari->Console->putString("\n"); + Akari->console->putString("EIP: "); + Akari->console->putInt(r->callback.eip, 16); + Akari->console->putString(", ESP: "); + Akari->console->putInt(r->callback.esp, 16); + Akari->console->putString(", EBP: "); + Akari->console->putInt(r->callback.ebp, 16); + Akari->console->putString(", CS: "); + Akari->console->putInt(r->callback.cs, 16); + Akari->console->putString(", EFLAGS: "); + Akari->console->putInt(r->callback.eflags, 16); + Akari->console->putString(", user ESP (may be garbage): "); + Akari->console->putInt(r->useresp, 16); + Akari->console->putString("\n"); while (1) __asm__ __volatile__("hlt"); @@ -64,6 +64,6 @@ void *irq_handler(struct modeswitch_registers *r) { AkariOutB(0xA0, 0x20); // EOI to slave IRQ controller AkariOutB(0x20, 0x20); // EOI to master IRQ controller - return Akari->Descriptor->irqt->callHandler(r->callback.int_no - 0x20, r); + return Akari->descriptor->irqt->callHandler(r->callback.int_no - 0x20, r); } interrupts.cpp Task.cpp inc/Task.hpp c7e4b2c08cec8c22648df4c388ab64cac44bd5ca Arlen Cuss celtic@sairyx.org http://github.com/celtic/akari/commit/6146d9e74bc067d0dbafb2e03358a248a82ef497 6146d9e74bc067d0dbafb2e03358a248a82ef497 2009-10-09T23:48:50-07:00 2009-10-09T23:48:50-07:00 Dropping the uppercase letters on the members of Akari, changing Task to Tasks so there's no conflict, and making the rest of the code match. ac3edee8d311e5450923494a489c2404378c5187 Arlen Cuss celtic@sairyx.org