SampleKernel.v014/0000755000175000017500000000000010716326747013666 5ustar k-imotok-imotoSampleKernel.v014/gdt.h0000644000175000017500000000262510716242644014613 0ustar k-imotok-imoto#ifndef __GDT_H__ #define __GDT_H__ #include "types.h" #include "descripter.h" struct GdtEntry { enum { G_FLAG = 0x0800, D_FLAG = 0x0400, AVL_FLAG = 0x0100, P_FLAG = 0x0080, DPL0 = 0x0000, DPL1 = 0x0020, DPL2 = 0x0040, DPL3 = 0x0060, S_FLAG = 0x0010, TYPE_CS = 0x000A, TYPE_DS = 0x0002, TYPE_SS = 0x0006, A_FLAG = 0x0001 }; uint16 limit_low; uint16 segbase_low; uint8 segbase_mid; uint8 type_low; uint8 type_hi :4; uint8 limit_hi :4; uint8 segbase_hi; } __attribute__ ((packed)); class Gdt { public: static const int NUM = 8192; enum { NULL_S = 0, KERNEL_CS = 1, KERNEL_DS = 2 }; static const uint16 KERNEL_CS_FLAG = (GdtEntry::G_FLAG | GdtEntry::D_FLAG | GdtEntry::P_FLAG | GdtEntry::DPL0 | GdtEntry::S_FLAG | GdtEntry::TYPE_CS); static const uint16 KERNEL_DS_FLAG = (GdtEntry::G_FLAG | GdtEntry::D_FLAG | GdtEntry::P_FLAG | GdtEntry::DPL0 | GdtEntry::S_FLAG | GdtEntry::TYPE_DS); void init(void); void set(int index, uint32 segbase, uint32 limit, uint16 type); void load(void) const; private: DescripterTable table __attribute__((aligned(8))); GdtEntry entry[NUM] __attribute__((aligned(8))); }; #endif /* __GDT_H__ */ SampleKernel.v014/kernel.cc0000644000175000017500000001205310716322764015451 0ustar k-imotok-imoto/* kernel.c - the C part of the kernel */ /* Copyright (C) 1999 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ extern "C" { #include void cmain (unsigned long magic, unsigned long addr); } #include "kernel.h" #include "screen.h" #include "gdt.h" #include "idt.h" #include "intmgr.h" #include "keyboard.h" #include "memmgr.h" #include "timer.h" #include "task.h" /* Variables. */ Gdt Gdt; Idt Idt; KeyboardInterruptHandler KeyIntHandler; Task IdleTask((uint8*)stack, STACK_SIZE); MsgQueue Kernel::message; /* For Timer Test */ class JobTest : public TimerJob { private: Timer& timer; public: JobTest(Timer& timer_, uint32 dur) : TimerJob(dur), timer(timer_) {} void onExpire(void) { Console.printf("JobTest\n"); timer.add(*this); } }; class TaskSwitcher : public TimerJob { private: Timer& timer; public: TaskSwitcher(Timer& timer_, uint32 dur) : TimerJob(dur), timer(timer_) {} void onExpire(void) { timer.add(*this); SystemScheduler.dispatch(false); } }; class TestTask : public Task { public: TestTask(size_t sz) : Task(sz) {} void run(void) { int i = 0; Console.printf("Task 3 run ! \n"); while(1) { asm volatile ("hlt"); ++i; if (i % 100 == 0) Console.printf("3"); } } } task3(0x400); /* Forward declarations. */ void itoa (char *buf, int base, int d); void cmain (unsigned long magic, unsigned long addr) { Kernel::initGlobalObjects(); Console.clear(); /* Am I booted by a Multiboot-compliant boot loader? */ if (magic != MULTIBOOT_BOOTLOADER_MAGIC) { Console.printf ("Invalid magic number: 0x%x\n", (unsigned) magic); return; } /* Set MBI to the address of the Multiboot information structure. */ multiboot_info_t* mbi = (multiboot_info_t*)addr; /* Are mem_* valid? */ if ((mbi->flags & MBI_FLAG_MEM_INFO_VALID) != 0) { Console.printf ("mem_lower = %uKB, mem_upper = %uKB\n", (unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper); } /* Bits 4 and 5 are mutually exclusive! */ if ((mbi->flags & MBI_FLAG_AOUT_SYM_VALID) != 0 && (mbi->flags & MBI_FLAG_ELF_SEC_VALID) != 0) { Console.printf ("Both bits 4 and 5 are set.\n"); return; } MemoryManager.init(mbi); // Enalbe alloc/free from here !! Gdt.init(); Idt.init(); InterruptManager.init(); // Enable interrupts from here !! InterruptManager.connect(IntMgr::KEYBOARD_IRQ, KeyIntHandler); InterruptManager.clearMask(IntMgr::KEYBOARD_MASK); SystemScheduler.init(IdleTask); SystemScheduler.add(task3); SystemTimer.init(); // Setup timer interrupt TimerJob* job = new TaskSwitcher(SystemTimer, 2); SystemTimer.add(*job); job = new JobTest(SystemTimer, 500); SystemTimer.add(*job); while (true) { uint8 msg = Kernel::waitForMsg(); Console.printf("KEY MSG[%x]\n", msg); } } /* Convert the integer D to a string and save the string in BUF. If BASE is equal to 'd', interpret that D is decimal, and if BASE is equal to 'x', interpret that D is hexadecimal. */ void itoa (char *buf, int base, int d) { char *p = buf; char *p1, *p2; unsigned long ud = d; int divisor = 10; /* If %d is specified and D is minus, put `-' in the head. */ if (base == 'd' && d < 0) { *p++ = '-'; buf++; ud = -d; } else if (base == 'x') divisor = 16; /* Divide UD by DIVISOR until UD == 0. */ do { int remainder = ud % divisor; *p++ = (remainder < 10) ? remainder + '0' : remainder + 'a' - 10; } while (ud /= divisor); /* Terminate BUF. */ *p = 0; /* Reverse BUF. */ p1 = buf; p2 = p - 1; while (p1 < p2) { char tmp = *p1; *p1 = *p2; *p2 = tmp; p1++; p2--; } } // Global constructor/destructor void Kernel::initGlobalObjects(void) { extern const func_t __CTOR_LIST__[1]; int32 i = (int32)__CTOR_LIST__[0]; const func_t *p; if (i == -1) { for (i = 1; __CTOR_LIST__[i] != 0; i++); i--; } p = __CTOR_LIST__ + i; while (i--) (**p--)(); } // for "halt message" in boot.S extern "C" void printf(const char* format, ...) { Console.printf(format); } extern "C" void __cxa_pure_virtual(void) { Kernel::panic("Call pure virtual function\n"); } SampleKernel.v014/types.h0000644000175000017500000000111110716242644015166 0ustar k-imotok-imoto#ifndef __TYPES_H__ #define __TYPES_H__ #define NULL (0) #define TRUE (1) #define FALSE (0) typedef unsigned char uchar; typedef unsigned short ushort; typedef unsigned int uint; typedef unsigned long ulong; typedef char int8; typedef short int16; typedef long int32; typedef unsigned char uint8; typedef unsigned short uint16; typedef unsigned long uint32; typedef unsigned int size_t; typedef unsigned int time_t; typedef void (*func_t)(void); typedef void (*callback_t)(void*); #define BIT(n) (1 << n) #ifdef __cplusplus class Object {}; #endif #endif /* __TYPES_H__ */ SampleKernel.v014/idt.h0000644000175000017500000000107710716242644014615 0ustar k-imotok-imoto#ifndef __IDT_H__ #define __IDT_H__ #include "types.h" #include "descripter.h" struct IdtEntry { uint16 offset_low; uint16 selector; uint16 copy :8; uint16 type :8; uint16 offset_hi; } __attribute__ ((packed)); class Idt { public: static const int NUM = 256; void init(void); void set(int index, uint32 offset, uint16 selector, uint8 copy, uint8 type); void load(void) const; private: DescripterTable table __attribute__((aligned(8))); IdtEntry entry[NUM] __attribute__((aligned(8))); }; #endif /* __IDT_H__ */ SampleKernel.v014/timer.cc0000644000175000017500000000311410716242644015305 0ustar k-imotok-imoto#include "kernel.h" #include "ioport.h" #include "timer.h" #include "intmgr.h" #include "screen.h" Timer SystemTimer; class TimerInterruptHandler : public InterruptHandler { private: Timer& timer; public: TimerInterruptHandler(Timer& tm) : timer(tm) {} void operator()(uint32 intNum) { ++timer; IntMgr::setEoi(IntMgr::TIMER_IRQ); } }; TimerInterruptHandler TimerIntHandler(SystemTimer); Timer::Timer(void) : Count(0), JobQueue(JobCmp) {} void Timer::init(void) { IoPortLib::out8(IoPortLib::PIT_CTRL, 0x34); IoPortLib::out8(IoPortLib::PIT_CNT0, 0x9C); IoPortLib::out8(IoPortLib::PIT_CNT0, 0x2E); InterruptManager.connect(IntMgr::TIMER_IRQ, TimerIntHandler); InterruptManager.clearMask(IntMgr::TIMER_MASK); } void Timer::add(TimerJob& job) { InterruptManager.disable(); job.Start = Count; job.Timeout = Count + job.Duration; JobQueue.enqueue(job); InterruptManager.enable(); } void Timer::abort(TimerJob& job) { InterruptManager.disable(); JobQueue.remove(job); InterruptManager.enable(); } Timer& Timer::operator++(void) { if (++Count > MAX_COUNT) Count = 0; TimerJob* job = (TimerJob*)JobQueue.peek(0); if (job != 0) { checkExpire(*job); } return *this; } void Timer::checkExpire(TimerJob& job) { if (job.Start > Count) { if (Timer::MAX_COUNT + Count > job.Timeout) { JobQueue.remove(job); job.onExpire(); } } else { if (job.Timeout < Count) { JobQueue.remove(job); job.onExpire(); } } } SampleKernel.v014/test.cc0000644000175000017500000000034110716272442015142 0ustar k-imotok-imoto#include "task.h" #include "screen.h" void test(void) { // Task* task = Scheduler.getCurrentTask(); // TCB* tcb = &task->getTcb(); TCB* tcb = Scheduler.getCurrentTcb(); Console.printf("%x\n", (uint32)tcb); } SampleKernel.v014/list.h0000644000175000017500000000072610716242644015010 0ustar k-imotok-imoto#include "types.h" class List { public: List(void) : top(0), bottom(0) {} void add(Object& object); void insert(uint32 i, Object& object); void remove(Object& object); Object* get(uint32 i); bool isEmpty(void) {return top == 0;} private: struct Node { Node* prev; Node* next; Object* value; }; Node* getNode(Object& object); Node* getNode(uint32 i); Node* top; Node* bottom; }; SampleKernel.v014/gdt.cc0000644000175000017500000000225310716242644014746 0ustar k-imotok-imoto#include "gdt.h" void Gdt::init(void) { table.limit = Gdt::NUM * sizeof(GdtEntry) - 1; table.offset = (uint32)entry; for (int i = 0; i < Gdt::NUM; i++) { set(i, 0, 0, 0); } set(NULL_S, 0, 0, 0); // for Null seg set(KERNEL_CS, 0, 0xFFFFF, KERNEL_CS_FLAG); // for Kernel code set(KERNEL_DS, 0, 0xFFFFF, KERNEL_DS_FLAG); // for Kernel data load(); /* Change segments */ asm("ljmp %0, $1f; 1:" : : "i" (KERNEL_CS * sizeof(GdtEntry))); asm("mov %0, %%ax" : : "i" (KERNEL_DS * sizeof(GdtEntry))); asm("mov %ax, %ds"); asm("mov %ax, %es"); asm("mov %ax, %fs"); asm("mov %ax, %gs"); asm("mov %ax, %ss"); } void Gdt::set(int index, uint32 segbase, uint32 limit, uint16 type) { GdtEntry& desc = entry[index]; desc.limit_low = limit & 0xFFFF; desc.limit_hi = (limit >> 16) & 0xF; desc.segbase_low = segbase & 0xFFFF; desc.segbase_mid = (segbase >> 16) & 0xFF; desc.segbase_hi = (segbase >> 24) & 0xFF; desc.type_low = type & 0xFF; desc.type_hi = (type >> 8) & 0xF; } void Gdt::load(void) const { __asm__ __volatile__("lgdt %0" :: "m" (table)); } SampleKernel.v014/Makefile0000644000175000017500000000264110716242644015322 0ustar k-imotok-imotoTARGET= kernel MAPFILE= kernel.map START= 0x100000 CC=/usr/bin/gcc CXX=/usr/bin/g++ CFLAGS= -nostdlib -nostdinc -fno-stack-protector -Wall -fno-builtin -O2 CXXFLAGS= $(CFLAGS) -fno-exceptions -fno-rtti -fno-strict-aliasing -Wno-non-virtual-dtor INCFLAGS= -I. LDFLAGS= -Ttext $(START) -e start -Map $(MAPFILE) OBJS= boot.o kernel.o asmcore.o gdt.o idt.o intmgr.o crtbegin.o crtend.o memmgr.o timer.o list.o screen.o task.o .c.o: $(CC) $(CFLAGS) $(INCFLAGS) -c $*.c .cc.o: $(CXX) $(CXXFLAGS) $(INCFLAGS) -c $*.cc .S.o: $(CC) $(CFLAGS) $(INCFLAGS) -c $*.S all: $(TARGET) $(TARGET): $(OBJS) $(LD) $(LDFLAGS) -o $@ $(OBJS) clean:: rm -f $(TARGET) $(MAPFILE) $(OBJS) *~ boot.o: Makefile types.h boot.S multiboot.h kernel.o: Makefile types.h kernel.cc kernel.h multiboot.h timer.h idt.h gdt.h intmgr.h memmgr.h gdt.o: Makefile gdt.h gdt.cc descripter.h types.h idt.o: Makefile idt.h idt.cc descripter.h types.h intmgr.o: Makefile types.h intmgr.cc intmgr.h ioport.h memmgr.o: Makefile types.h memmgr.cc memmgr.h multiboot.h asmcore.o: Makefile asmcore.S crtbegin.o: Makefile types.h crtbegin.c crtend.o: Makefile types.h crtend.c timer.o: Makefile types.h timer.h timer.cc ioport.h list.h list.o: Makefile types.h list.h list.cc screen.o: Makefile types.h screen.h screen.cc task.o: Makefile types.h task.h task.cc install:: $(TARGET) sudo mount -t vfat /dev/fd0 ~/floppy sudo cp kernel ~/floppy/boot/. sudo umount ~/floppy SampleKernel.v014/asmcore.S0000644000175000017500000000272010716302246015430 0ustar k-imotok-imoto.text int_nestcnt: .long 0 .macro asm_int_handler intno .global asm_int_handler\intno asm_int_handler\intno: pusha pushl %gs pushl %fs pushl %es pushl %ds cli movl int_nestcnt, %eax addl $1, %eax movl %eax, int_nestcnt cmpl $1, %eax jne 1f movl _ZN13TaskScheduler10CurrentTcbE, %ebx movl %esp, %edx movl %edx, 4(%ebx) 1: sti pushl $\intno pushl $InterruptManager call _ZN6IntMgr15dispatchHandlerENS_6IrqNumE addl $8, %esp cli movl int_nestcnt, %eax subl $1, %eax movl %eax, int_nestcnt cmpl $0, %eax jne 1f movl _ZN13TaskScheduler10CurrentTcbE, %eax jmp _context_restore 1: jmp _load_context .endm .global task_dispatch task_dispatch: cli movl 4(%esp), %eax push %cs call _context_change sti ret .global _context_change .global _context_restore _context_change: pushl %eax pushl %eax pushf movl 12(%esp), %eax movl %eax, 8(%esp) movl 16(%esp), %eax movl %eax, 12(%esp) movl (%esp), %eax movl %eax, 16(%esp) addl $4, %esp popl %eax pusha pushl %gs pushl %fs pushl %es pushl %ds movl _ZN13TaskScheduler10CurrentTcbE, %ebx movl %esp, %edx movl %edx, 4(%ebx) _context_restore: movl 4(%eax), %edx movl %edx, %esp /* current task change!! */ movl %eax, _ZN13TaskScheduler10CurrentTcbE _load_context: popl %ds popl %es popl %fs popl %gs popa iret asm_int_handler 0 asm_int_handler 1 SampleKernel.v014/memmgr.h0000644000175000017500000000233710716242644015321 0ustar k-imotok-imoto#ifndef __MEMMGR_H__ #define __MEMMGR_H__ extern "C" { #include "multiboot.h" } #include "types.h" struct Region { uint32 start; size_t size; Region* prev; Region* next; }; class RegionList { public: RegionList(void) : top(0), bottom(0) {} void add(Region& region); void remove(Region& region); Region* merge(Region& region); Region* get(uint32 i); Region* searchBySize(size_t size); Region* searchByAddr(void* addr); void show(void); private: Region* top; Region* bottom; }; class MemMgr { public: MemMgr(void); void init(multiboot_info_t* mbi); void* alloc(size_t size); void free(void* addr); // void* realloc(void* addr, size_t size); private: static const uint32 PAGE_SIZE = 0x1000; static const uint32 REGION_NUM = 1000; // Temporary uint32 start; size_t size; RegionList allocs; RegionList notassigns; RegionList frees; Region regions[REGION_NUM]; size_t getAllocSize(size_t size) const { return ((size + PAGE_SIZE - 1) / PAGE_SIZE) * PAGE_SIZE; } }; extern MemMgr MemoryManager; extern void* operator new(size_t size); extern void operator delete(void* addr); #endif /* __MEMMGR_H__ */ SampleKernel.v014/ToDo.txt0000644000175000017500000000040510716323350015256 0ustar k-imotok-imoto- Support of task slice time - Support of sleep(Wait/SendEvt) - Support of Event Queue in Task Class - Makes CurrentTcb private member of TaskScheduler class - Support of display resolution change - Create "idle task" done. 014 - Support of task priority SampleKernel.v014/list.cc0000644000175000017500000000337710716242644015153 0ustar k-imotok-imoto#include "memmgr.h" #include "list.h" void List::add(Object& object) { Node* node = new Node; if (node != 0) { node->value = &object; node->next = 0; node->prev = bottom; if (bottom == 0) { top = node; } else { bottom->next = node; } bottom = node; } } void List::insert(uint32 i, Object& object) { Node* node = getNode(i); if (node == 0) { add(object); } else { Node* new_node = new Node; if (new_node != 0) { new_node->value = &object; if (node->prev != 0) { node->prev->next = new_node; new_node->prev = node->prev; } else { new_node->prev = 0; top = new_node; } new_node->next = node; node->prev = new_node; } } } void List::remove(Object& object) { Node* node = getNode(object); if (node != 0) { if (node->prev == 0) { top = node->next; } else { node->prev->next = node->next; } if (node->next == 0) { bottom = node->prev; } else { node->next->prev = node->prev; } MemoryManager.free(node); } } Object* List::get(uint32 i) { Node* node = getNode(i); return (node != 0) ? node->value : 0; } List::Node* List::getNode(Object& object) { Node* node = 0; for (node = top; node != 0; node = node->next) { if (&object == node->value) break; } return (node != 0) ? node : 0; } List::Node* List::getNode(uint32 i) { Node* node = top; for (uint32 j = 0; j < i; j++) { if (node == 0) break; node = node->next; } return node; } SampleKernel.v014/keyboard.h0000644000175000017500000000053410716242644015632 0ustar k-imotok-imoto#ifndef __KEYBOARD_H__ #define __KEYBOARD_H__ #include "intmgr.h" class KeyboardInterruptHandler : public InterruptHandler { public: void operator()(uint32 intNum) { uint8 data = IoPortLib::in8(IoPortLib::KBD_DATA); IntMgr::setEoi(IntMgr::KEYBOARD_IRQ); Kernel::sendMessage(data); } }; #endif /*__KEYBOARD_H__ */ SampleKernel.v014/kernel.h0000644000175000017500000000250410716242644015311 0ustar k-imotok-imoto#ifndef __KERNEL_H__ #define __KERNEL_H__ #include "types.h" #include "intmgr.h" #include "screen.h" class MsgQueue { public: MsgQueue(void) {top = next = num = 0;} void enqueue(uint8 msg) { IntMgr::disable(); data[next] = msg; if (++next >= NUM) next = 0; ++num; IntMgr::enable(); } uint8 dequeue(void) { IntMgr::disable(); uint8 msg = data[top]; if (++top >= NUM) top = 0; --num; IntMgr::enable(); return msg; } bool isEmpty(void) {return num == 0;} private: enum {NUM=128}; uint8 data[NUM]; uint32 top; uint32 next; uint32 num; }; class Kernel { public: static void initGlobalObjects(void); static void sendMessage(uint8 msg) {message.enqueue(msg);} static uint8 waitForMsg(void) { while (true) { if (message.isEmpty()) { asm("hlt"); } else { return message.dequeue(); } } } static void panic(const char* format, ...) { Console.printf("[Kernel Panic] "); Console.printf(format); while (true) { InterruptManager.disable(); asm volatile("hlt"); } } private: static MsgQueue message; }; extern void* stack; #endif /* __KERNEL_H__ */ SampleKernel.v014/idt.cc0000644000175000017500000000157310716242644014754 0ustar k-imotok-imoto#include "idt.h" #include "gdt.h" extern "C" { extern void asm_int_handler0(void); extern void asm_int_handler1(void); } void Idt::init(void) { table.limit = Idt::NUM * sizeof(IdtEntry) - 1; table.offset = (uint32)entry; for (int i = 0; i < Idt::NUM; i++) { set(i, 0, 0, 0, 0); } set(0x20, (uint32)asm_int_handler0, Gdt::KERNEL_CS * sizeof(GdtEntry), 0, 0x8E); set(0x21, (uint32)asm_int_handler1, Gdt::KERNEL_CS * sizeof(GdtEntry), 0, 0x8E); load(); } void Idt::set(int index, uint32 offset, uint16 selector, uint8 copy, uint8 type) { IdtEntry& desc = entry[index]; desc.offset_low = offset & 0xFFFF; desc.offset_hi = (offset >> 16) & 0xFFFF; desc.selector = selector; desc.copy = copy; desc.type = type; } void Idt::load(void) const { __asm__ __volatile__("lidt %0" :: "m" (table)); } SampleKernel.v014/queue.h0000644000175000017500000000151010716242644015151 0ustar k-imotok-imoto#ifndef __QUE_H__ #define __QUE_H__ #include "intmgr.h" #include "list.h" class Queue : public List { public: Queue(void) {} Object* peek(uint32 i) {return get(i);} virtual void enqueue(Object& obj) { add(obj); } Object* dequeue(void) { Object* obj = peek(0); if (obj != 0) remove(*obj); return obj; } }; class Comparator { public: virtual int compare(Object& src1, Object& src2) = 0; }; class PriorityQueue : public Queue { public: PriorityQueue(Comparator& c) : Cmp(c) {} void enqueue(Object& obj) { uint32 i = 0; Object* entry = peek(i); while (entry != 0) { if (Cmp.compare(obj, *entry) < 0) break; entry = peek(++i); } insert(i, obj); } private: Comparator& Cmp; }; #endif /* __QUE_H__ */ SampleKernel.v014/intmgr.h0000644000175000017500000000345710716242644015341 0ustar k-imotok-imoto#ifndef __INTMGR_H__ #define __INTMGR_H__ #include "ioport.h" #include "types.h" class InterruptHandler; class IntMgr { public: enum IrqNum { TIMER_IRQ = 0, KEYBOARD_IRQ = 1, SLAVE_IRQ = 2, COM2_IRQ = 3, COM1_IRQ = 4, LPT2_IRQ = 5, FDD_IRQ = 6, LPT1_IRQ = 7, RTCLK_IRQ = 8, MOUSE_IRQ = 12, FPU_IRQ = 13, IDE_P_IRQ = 14, IDE_S_IRQ = 15, IRQ_NUM = 16 }; enum IntMask { TIMER_MASK = BIT(TIMER_IRQ), KEYBOARD_MASK = BIT(KEYBOARD_IRQ), SLAVE_MASK = BIT(SLAVE_IRQ), COM2_MASK = BIT(COM2_IRQ), COM1_MASK = BIT(COM1_IRQ), LPT2_MASK = BIT(LPT2_IRQ), FDD_MASK = BIT(FDD_IRQ), LPT1_MASK = BIT(LPT1_IRQ), RTCLK_MASK = BIT(RTCLK_IRQ), MOUSE_MASK = BIT(MOUSE_IRQ), FPU_MASK = BIT(FPU_IRQ), IDE_P_MASK = BIT(IDE_P_IRQ), IDE_S_MASK = BIT(IDE_S_IRQ), ALL_MASK = 0xFFFF }; void init(void); static void setMask(uint16 mask); static void clearMask(uint16 mask); static void disable(void) {asm("cli");} static void enable(void) {asm("sti");} static void setEoi(IrqNum n) { const IoPortLib::IoPort port = (n < 8) ? IoPortLib::PIC0_OCW2 : IoPortLib::PIC1_OCW2; int num = (n < 8) ? int(n) : int(n) - 8; IoPortLib::out8(port, 0x60 + num); } void connect(IrqNum irq, InterruptHandler& handler); void dispatchHandler(IrqNum irq); private: InterruptHandler* handler[IRQ_NUM]; }; class InterruptHandler { public: virtual void operator()(uint32 intNum) {} }; extern IntMgr InterruptManager; #endif /* __INTMGR_H__ */ SampleKernel.v014/timer.h0000644000175000017500000000165510716242644015157 0ustar k-imotok-imoto#ifndef __TIMER_H__ #define __TIMER_H__ #include "queue.h" class Timer; class TimerJob : public Object { friend class Timer; public: TimerJob(uint32 dur) : Start(0), Timeout(0), Duration(dur) {} virtual void onExpire(void) {}; private: uint32 Start; uint32 Timeout; uint32 Duration; }; class Timer { public: static const uint32 MAX_COUNT = 0x7FFFFFFF; Timer(void); void init(void); void add(TimerJob& job); void abort(TimerJob& job); Timer& operator++(void); private: uint32 Count; PriorityQueue JobQueue; class TimerJobComparator : public Comparator { int compare(Object& src1, Object& src2) { TimerJob& job1 = (TimerJob&)src1; TimerJob& job2 = (TimerJob&)src2; return int(job1.Timeout - job2.Timeout); } } JobCmp; void checkExpire(TimerJob& job); }; extern Timer SystemTimer; #endif /*__TIMER_H__ */ SampleKernel.v014/multiboot.h0000644000175000017500000000535610716242644016057 0ustar k-imotok-imoto#ifndef __MULTIBOOT_H__ #define __MULTIBOOT_H__ /* The magic number for the Multiboot header. */ #define MULTIBOOT_HEADER_MAGIC 0x1BADB002 /* The flags for the Multiboot header. */ #ifdef __ELF__ # define MULTIBOOT_HEADER_FLAGS 0x00000003 #else # define MULTIBOOT_HEADER_FLAGS 0x00010003 #endif /* The magic number passed by a Multiboot-compliant boot loader. */ #define MULTIBOOT_BOOTLOADER_MAGIC 0x2BADB002 /* The size of our stack (16KB). */ #define STACK_SIZE 0x4000 /* C symbol format. HAVE_ASM_USCORE is defined by configure. */ #ifdef HAVE_ASM_USCORE # define EXT_C(sym) _ ## sym #else # define EXT_C(sym) sym #endif #ifndef ASM /* Do not include here in boot.S. */ # include "types.h" /* Types. */ /* The Multiboot header. */ typedef struct multiboot_header { unsigned long magic; unsigned long flags; unsigned long checksum; unsigned long header_addr; unsigned long load_addr; unsigned long load_end_addr; unsigned long bss_end_addr; unsigned long entry_addr; } multiboot_header_t; /* The symbol table for a.out. */ typedef struct aout_symbol_table { unsigned long tabsize; unsigned long strsize; unsigned long addr; unsigned long reserved; } aout_symbol_table_t; /* The section header table for ELF. */ typedef struct elf_section_header_table { unsigned long num; unsigned long size; unsigned long addr; unsigned long shndx; } elf_section_header_table_t; /* The Multiboot information. */ typedef struct multiboot_info { unsigned long flags; unsigned long mem_lower; unsigned long mem_upper; unsigned long boot_device; unsigned long cmdline; unsigned long mods_count; unsigned long mods_addr; union { aout_symbol_table_t aout_sym; elf_section_header_table_t elf_sec; } u; unsigned long mmap_length; unsigned long mmap_addr; } multiboot_info_t; /* The module structure. */ typedef struct module { unsigned long mod_start; unsigned long mod_end; unsigned long string; unsigned long reserved; } module_t; /* The memory map. Be careful that the offset 0 is base_addr_low but no size. */ typedef struct memory_map { unsigned long size; unsigned long base_addr_low; unsigned long base_addr_high; unsigned long length_low; unsigned long length_high; unsigned long type; } memory_map_t; enum mbi_flag_t { MBI_FLAG_MEM_INFO_VALID = BIT(0), MBI_FLAG_BOOT_DEVICE_VALID = BIT(1), MBI_FLAG_CMD_LINE_PASSED = BIT(2), MBI_FLAG_MODS_VALID = BIT(3), MBI_FLAG_AOUT_SYM_VALID = BIT(4), MBI_FLAG_ELF_SEC_VALID = BIT(5), MBI_FLAG_MMAP_VALID = BIT(6) }; #endif /* ! ASM */ #endif /* __MULTIBOOT_H__ */ SampleKernel.v014/crtend.c0000644000175000017500000000027110716242644015302 0ustar k-imotok-imoto#include "types.h" const func_t __CTOR_END__[1] __attribute__((section(".ctors"))) = {(void*)0}; const func_t __DTOR_END__[1] __attribute__((section(".dtors"))) = {(void*)0}; SampleKernel.v014/intmgr.cc0000644000175000017500000000324010716242644015465 0ustar k-imotok-imoto#include "kernel.h" #include "ioport.h" #include "intmgr.h" #include "screen.h" IntMgr InterruptManager; void IntMgr::init(void) { for (int i = 0; i < IRQ_NUM; i++) { handler[i] = 0; } IoPortLib::out8(IoPortLib::PIC0_ICW1, 0x11); IoPortLib::out8(IoPortLib::PIC0_ICW2, 0x20); IoPortLib::out8(IoPortLib::PIC0_ICW3, 0x04); IoPortLib::out8(IoPortLib::PIC0_ICW4, 0x01); IoPortLib::out8(IoPortLib::PIC1_ICW1, 0x11); IoPortLib::out8(IoPortLib::PIC1_ICW2, 0x28); IoPortLib::out8(IoPortLib::PIC1_ICW3, 0x02); IoPortLib::out8(IoPortLib::PIC1_ICW4, 0x01); setMask(ALL_MASK); clearMask(SLAVE_MASK); enable(); } void IntMgr::setMask(uint16 mask) { const uint8 mask0 = uint8(mask & 0xFF); const uint8 mask1 = uint8((mask >> 8) & 0xFF); IoPortLib::out8(IoPortLib::PIC0_IMR, IoPortLib::in8(IoPortLib::PIC0_IMR) | mask0); IoPortLib::out8(IoPortLib::PIC1_IMR, IoPortLib::in8(IoPortLib::PIC1_IMR) | mask1); } void IntMgr::clearMask(uint16 mask) { const uint8 mask0 = uint8(mask & 0xFF); const uint8 mask1 = uint8((mask >> 8) & 0xFF); IoPortLib::out8(IoPortLib::PIC0_IMR, IoPortLib::in8(IoPortLib::PIC0_IMR) & ~(mask0)); IoPortLib::out8(IoPortLib::PIC1_IMR, IoPortLib::in8(IoPortLib::PIC1_IMR) & ~(mask1)); } void IntMgr::connect(IrqNum irq, InterruptHandler& handler) { this->handler[irq] = &handler; } void IntMgr::dispatchHandler(IrqNum irq) { InterruptHandler* functor = handler[irq]; if (functor != 0) { (*functor)(irq); } else { Kernel::panic("[IntMgr] Null Pointer Exception\n"); } } SampleKernel.v014/task.h0000644000175000017500000000475110716326654015005 0ustar k-imotok-imoto#ifndef __TASK_H__ #define __TASK_H__ extern "C" { #include "multiboot.h" } #include "types.h" #include "queue.h" #include "memmgr.h" #include "gdt.h" class TaskScheduler; struct TaskContext { uint32 ds; uint32 es; uint32 fs; uint32 gs; uint32 edi; uint32 esi; uint32 ebp; uint32 esp; // do not use this value uint32 ebx; uint32 edx; uint32 ecx; uint32 eax; uint32 eip; uint32 cs; uint32 eflags; } __attribute__ ((packed)); struct TCB { uint32 StackSegment; TaskContext* Context; }; class Task : public Object { public: enum TaskStatus { RUNNING = 0, READY = 1, WAIT = 2, }; enum TaskPriority { MIN_PRIORITY = 0, NORMAL_PRIORITY = 128, MAX_PRIORITY = 255, }; Task(size_t stack_size); Task(uint8* sp, size_t stack_size) : Stack(sp), StackSize(stack_size), Priority(NORMAL_PRIORITY), Scheduler(0), isStackInMemPool(false) {} TCB& getTcb(void) {return Tcb;} void setStatus(TaskStatus st) {Status = st;} TaskPriority getPriority(void) {return Priority;} void setPriority(TaskPriority pri) {Priority = pri;} void attach(TaskScheduler& scheduler) {Scheduler = &scheduler;} void detach(void) {Scheduler = 0;} #if 0 /* Under immplementation */ Event& waitForEvent(void); void sendEvent(Event& evt); #endif virtual void run(void) {} private: TCB Tcb; uint8* Stack; size_t StackSize; TaskStatus Status; TaskPriority Priority; Queue EventQueue; TaskScheduler* Scheduler; bool isStackInMemPool; }; class TaskScheduler { public: TaskScheduler(void) : ReadyQueue(TaskCmp) {} void init(Task& current_task); void add(Task& task) {addReadyQueue(task); task.attach(*this);} void dispatch(bool dispatch_immd = true); Task* getCurrentTask(void) {return CurrentTask;} TCB* getCurrentTcb(void); static TCB* CurrentTcb; private: Task* CurrentTask; PriorityQueue ReadyQueue; class TaskComparator : public Comparator { int compare(Object& src1, Object& src2) { Task& t1 = (Task&)src1; Task& t2 = (Task&)src2; return int(t1.getPriority() - t2.getPriority()); } } TaskCmp; void addReadyQueue(Task& task) { ReadyQueue.add(task); task.setStatus(Task::READY); } }; extern TaskScheduler SystemScheduler; #endif /* __TASK_H__ */ SampleKernel.v014/boot.S0000644000175000017500000000432510716242644014752 0ustar k-imotok-imoto/* boot.S - bootstrap the kernel */ /* Copyright (C) 1999, 2001 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define ASM 1 #include .text .globl start, _start start: _start: jmp multiboot_entry /* Align 32 bits boundary. */ .align 4 /* Multiboot header. */ multiboot_header: /* magic */ .long MULTIBOOT_HEADER_MAGIC /* flags */ .long MULTIBOOT_HEADER_FLAGS /* checksum */ .long -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS) #ifndef __ELF__ /* header_addr */ .long multiboot_header /* load_addr */ .long _start /* load_end_addr */ .long _edata /* bss_end_addr */ .long _end /* entry_addr */ .long multiboot_entry #endif /* ! __ELF__ */ multiboot_entry: /* Initialize the stack pointer. */ movl $(stack + STACK_SIZE), %esp /* Reset EFLAGS. */ pushl $0 popf /* Push the pointer to the Multiboot information structure. */ pushl %ebx /* Push the magic value. */ pushl %eax /* Now enter the C main function... */ call EXT_C(cmain) /* Halt. */ pushl $halt_message call EXT_C(printf) loop: hlt jmp loop halt_message: .asciz "Halted.\n" /* Our stack area. */ /* stack: .byte STACK_SIZE */ .comm stack, STACK_SIZE SampleKernel.v014/event.h0000644000175000017500000000017010716321133015136 0ustar k-imotok-imoto#ifndef __EVENT_H__ #define __EVENT_H__ #include "types.h" class Event : public Object { }; #endif /* __EVENT_H__ */ SampleKernel.v014/screen.cc0000644000175000017500000000335310716242644015451 0ustar k-imotok-imoto#include "types.h" #include "screen.h" extern void itoa (char *buf, int base, int d); Screen Console; Screen::Screen(void) : xpos(0), ypos(0) { vram = (uint8*)VIDEO; clear(); } void Screen::clear(void) { for (int i = 0; i < COLUMNS * LINES * 2; i++) { vram[i] = 0; } xpos = ypos = 0; } void Screen::putchar(int c) { if (c != '\n' && c != '\r') { vram[(xpos + ypos * COLUMNS) * 2] = c & 0xFF; vram[(xpos + ypos * COLUMNS) * 2 + 1] = ATTRIBUTE; ++xpos; } if (c == '\n' || c == '\r' || xpos >= COLUMNS) { xpos = 0; ypos++; if (ypos >= LINES) { ypos--; scroll(); } return; } } void Screen::scroll(void) { for (int i = 0; i < COLUMNS * (LINES - 1) * 2; i++) { vram[i] = vram[i + COLUMNS * 2]; } for (int i = COLUMNS * (LINES - 1) * 2; i < COLUMNS * LINES * 2; i++) { vram[i] = 0; } } void Screen::printf(const char* format, ...) { char** arg = (char**)&format; int c; char buf[20]; ++arg; // point to args next to fmt while ((c = *format++) != 0) { if (c != '%') { putchar(c); } else { char* p; c = *format++; switch (c) { case 'd': case 'u': case 'x': itoa(buf, c, *((int*)arg++)); p = buf; goto string; break; case 's': p = *arg++; if (p == 0) p = "(null)"; string: while (*p != 0) putchar(*p++); break; default: putchar(*((int*)arg++)); break; } } } } SampleKernel.v014/task.cc0000644000175000017500000000460110716326621015127 0ustar k-imotok-imoto#include "kernel.h" #include "task.h" #include "intmgr.h" #include "screen.h" #include "gdt.h" TaskScheduler SystemScheduler; TCB* TaskScheduler::CurrentTcb; extern "C" void task_dispatch(TCB* tcb); extern "C" void TaskEntryPoint(Task* task) { task->run(); while(true) { __asm__ __volatile__("hlt"); } } //------------------------------------------------------------------- // Task Class Method //------------------------------------------------------------------- Task::Task(size_t stack_size) : StackSize(stack_size), Priority(NORMAL_PRIORITY), isStackInMemPool(true) { Stack = (uint8*)MemoryManager.alloc(StackSize); *((uint32*)&Stack[StackSize - 8]) = 0; // return address(dummy) *((uint32*)&Stack[StackSize - 4]) = (uint32)this; Tcb.Context = (TaskContext*)&Stack[StackSize - sizeof(TaskContext) - 8]; Tcb.Context->eflags = 0x0202; Tcb.Context->cs = Gdt::KERNEL_CS * sizeof(GdtEntry); Tcb.Context->eip = (uint32)TaskEntryPoint; Tcb.Context->ds = Gdt::KERNEL_DS * sizeof(GdtEntry); Tcb.Context->es = Tcb.Context->ds; Tcb.StackSegment = Tcb.Context->ds; Status = READY; } #if 0 /* Under immplementation */ Event& Task::waitForEvent(void) { if (EventQueue.isEmpty()) { if (Scheduler != 0) { Scheduler->makeWait(*this); } else { /* should throw any exception! */ } } return (Event&)*EventQueue.dequeue(); } void Task::sendEvent(Event& evt) { EventQueue.enqueue(evt); if (Scheduler != 0) { Scheduler->makeReady(*this); } } #endif //------------------------------------------------------------------- // TaskScheduler Class Method //------------------------------------------------------------------- void TaskScheduler::dispatch(bool dispatch_immd) { Task* next_task; if (((next_task = (Task*)ReadyQueue.dequeue()) != 0) && (CurrentTask->getPriority() <= next_task->getPriority())) { addReadyQueue(*CurrentTask); CurrentTask = next_task; CurrentTask->setStatus(Task::RUNNING); if (dispatch_immd) { task_dispatch(&CurrentTask->getTcb()); } else { CurrentTcb = &CurrentTask->getTcb(); } } } void TaskScheduler::init(Task& cur_task) { CurrentTask = &cur_task; CurrentTcb = &cur_task.getTcb(); } TCB* TaskScheduler::getCurrentTcb(void) { return &CurrentTask->getTcb(); } SampleKernel.v014/crtbegin.c0000644000175000017500000000027510716242644015624 0ustar k-imotok-imoto#include "types.h" const func_t __CTOR_LIST__[1] __attribute__((section(".ctors"))) = {(void*)-1}; const func_t __DTOR_LIST__[1] __attribute__((section(".dtors"))) = {(void*)-1}; SampleKernel.v014/memmgr.cc0000644000175000017500000001103010716242644015445 0ustar k-imotok-imoto #include "kernel.h" #include "screen.h" #include "memmgr.h" MemMgr MemoryManager; MemMgr::MemMgr(void) : notassigns(), frees() { for (uint32 i = 0; i < REGION_NUM; i++) { notassigns.add(regions[i]); } } void MemMgr::init(multiboot_info_t* mbi) { extern int _start; start = uint32(&_start); size = mbi->mem_upper * 1024; size_t kernel_size; if ((mbi->flags & MBI_FLAG_MODS_VALID) != 0) { // mods valid ? module_t* mode = (module_t*)mbi->mods_addr; kernel_size = mode[mbi->mods_count - 1].mod_end - start; } else { extern void* _end; kernel_size = uint32(&_end) - start; } // create free list Region* free_region = notassigns.get(0); if (free_region != 0) { notassigns.remove(*free_region); free_region->start = start + kernel_size; free_region->size = size - kernel_size; frees.add(*free_region); } } void* MemMgr::alloc(size_t size) { void* addr = 0; if (size != 0) { IntMgr::disable(); size = getAllocSize(size); Region* free_region = frees.searchBySize(size); Region* alloc_region = notassigns.get(0); if ((free_region != 0) && (alloc_region != 0)) { notassigns.remove(*alloc_region); alloc_region->start = free_region->start; alloc_region->size = size; allocs.add(*alloc_region); addr = (void*)(alloc_region->start); free_region->start += size; free_region->size -= size; if (free_region->size == 0) { frees.remove(*free_region); notassigns.add(*free_region); } } IntMgr::enable(); } return addr; } void MemMgr::free(void* addr) { if (addr != 0) { IntMgr::disable(); Region* alloc_region = allocs.searchByAddr(addr); if (alloc_region != 0) { allocs.remove(*alloc_region); // merge free regions, if you can. Region* merge_region; while ((merge_region = frees.merge(*alloc_region)) != 0) { notassigns.add(*alloc_region); alloc_region = merge_region; frees.remove(*alloc_region); } frees.add(*alloc_region); } IntMgr::enable(); } } void RegionList::add(Region& region) { region.next = 0; region.prev = bottom; if (bottom == 0) { top = ®ion; } else { bottom->next = ®ion; } bottom = ®ion; } void RegionList::remove(Region& region) { if (region.prev == 0) { top = region.next; } else { region.prev->next = region.next; } if (region.next == 0) { bottom = region.prev; } else { region.next->prev = region.prev; } region.prev = region.next = 0; } Region* RegionList::merge(Region& region) { Region* merge_region = 0; for (Region* r = top; r != 0; r = r->next) { if (region.start + region.size == r->start) { r->start = region.start; r->size += region.size; merge_region = r; break; } else if (r->start + r->size == region.start) { r->size += region.size; merge_region = r; break; } } return merge_region; } Region* RegionList::get(uint32 i) { Region* region = top; for (uint32 j = 0; j < i; j++) { if (region == 0) break; region = region->next; } return region; } Region* RegionList::searchBySize(size_t size) { Region* target_region = 0; for (Region* region = top; region != 0; region = region->next) { if (region->size >= size) { target_region = region; break; } } return target_region; } Region* RegionList::searchByAddr(void* addr) { Region* target_region = 0; for (Region* region = top; region != 0; region = region->next) { if (region->start == uint32(addr)) { target_region = region; break; } } return target_region; } void RegionList::show(void) { Console.printf("list :: top(%x), bottom(%x)\n", uint32(top), uint32(bottom)); Region* region = top; while (region != 0) { Console.printf(" reg[%x] :: start(%x), size(%x)\n", uint32(region), region->start, region->size); region = region->next; } } // new / delete void* operator new(size_t size) { return MemoryManager.alloc(size); } void operator delete(void* addr) { MemoryManager.free(addr); } SampleKernel.v014/ioport.h0000644000175000017500000000313210716242644015343 0ustar k-imotok-imoto#ifndef __IOPORT_H__ #define __IOPORT_H__ #include "types.h" class IoPortLib { public: enum IoPort { PIC0_ICW1 = 0x20, PIC0_ICW2 = 0x21, PIC0_ICW3 = 0x21, PIC0_ICW4 = 0x21, PIC0_OCW1 = 0x21, PIC0_OCW2 = 0x20, PIC0_OCW3 = 0x20, PIC0_IMR = 0x21, PIC1_ICW1 = 0xa0, PIC1_ICW2 = 0xa1, PIC1_ICW3 = 0xa1, PIC1_ICW4 = 0xa1, PIC1_OCW1 = 0xa1, PIC1_OCW2 = 0xa0, PIC1_OCW3 = 0xa0, PIC1_IMR = 0xa1, PIT_CNT0 = 0x40, PIT_CNT1 = 0x41, PIT_CNT2 = 0x42, PIT_CTRL = 0x43, KBD_DATA = 0x60, KBD_STS = 0x61, }; static __inline void out8(uint16 port, uint8 value) { __asm__ __volatile__ ("outb %%al, %%dx" :: "d" (port), "a" (value)); } static void out16(IoPort port, uint16 value) { __asm__ __volatile__ ("outw %%ax, %%dx" :: "d" (port), "a" (value)); } static void out32(IoPort port, uint32 value) { __asm__ __volatile__ ("outl %%eax, %%dx" :: "d" (port), "a" (value)); } static uint8 in8(IoPort port) { uint8 value; __asm__ __volatile__ ("inb %%dx, %%al" : "=a" (value) : "d" (port)); return value; } static uint8 in16(IoPort port) { uint16 value; __asm__ __volatile__ ("inw %%dx, %%ax" : "=a" (value) : "d" (port)); return value; } static uint8 in32(IoPort port) { uint32 value; __asm__ __volatile__ ("inl %%dx, %%eax" : "=a" (value) : "d" (port)); return value; } }; #endif /* __IOPORT_H__ */ SampleKernel.v014/screen.h0000644000175000017500000000065410716316167015316 0ustar k-imotok-imoto#ifndef __SCREEN_H__ #define __SCREEN_H__ class Screen { public: Screen(void); void clear(void); void putchar(int c); void printf(const char* format, ...); private: enum { VIDEO = 0xB8000, COLUMNS = 80, LINES = 24, ATTRIBUTE = 7, }; volatile uint8* vram; uint32 xpos, ypos; void scroll(void); }; extern Screen Console; #endif /* __SCREEN_H__ */ SampleKernel.v014/descripter.h0000644000175000017500000000025610716242644016177 0ustar k-imotok-imoto#ifndef __DESCRIPTER_H__ #define __DESCRIPTER_H__ struct DescripterTable { uint16 limit; uint32 offset; } __attribute__ ((packed)); #endif /* __DESCRIPTER_H__ */