int kernelConnect_init(void) {
device_init();
syscall_init();
//thread = test_init();
return 0;
}
// TODO: Kernel init functions, kernel_early_init stub is here, kernel_init is just a declaration to shut the linker up.
void kernel_early_init(struct multiboot *mboot_header, addr_t initial_stack)
{
// This is fun, but as long as grub is a bitch, i have a problem.
// Make sure interrupts are disabled.
//asm volatile("cli");
// Store passed values, and set up the early system.
kernel_state_flags = 0;
set_ksf(KSF_BOOTING);
mtboot = mboot_header;
initial_boot_stack = initial_stack;
loader_parse_kernel_elf(mboot_header, &kernel_sections);
#if _DBOS_KERNEL_LOADER_MODULES
loader_init_kernel_symbols();
#endif
serial_init();
cpu_early_init();
#if _DBOS_KERNEL_LOADER_MODULES
loader_init_modules();
#endif
syscall_init();
cpu_timer_install(1000);
cpu_processor_init_1();
printk(8, "[KERNEL]: Parsed kernel elf, end of stub function. If you see this, then it is working.\n");
printk(1, "[KERNEL]: Starting system management.\n");
mm_init(mtboot);
tm_init_multitasking();
dm_init();
fs_init();
}
void kmain(s64 magic, s64 info)
{
//vga_clear(COLOR_BLACK);
idt_init();
isr_init();
serial_init();
set_debug_traps();
BREAKPOINT();
cpuid_print();
multiboot(magic, info);
kmem_map();
page_init();
kmalloc_init();
//vesa_init();
root_init();
pci_init();
vm_init();
syscall_init();
timer_init();
kbd_init();
//mouse_init();
console_init();
create_kthread(NULL, idle_thread, THREAD_PRI_LOW, NULL, NULL);
create_kthread(NULL, init_thread, THREAD_PRI_NORMAL, NULL, NULL);
thread_schedule();
}
// Initialisation routine - zeroes all the interrupt service routines,
// initialises the GDT and IDT.
void gaia_init(void)
{
gdt_init(); // Initialise the global descriptor table.
idt_init(); // Initialise the interrupt descriptor table.
// paging_init();
syscall_init();
// Enable interruptions
asm volatile("sti");
}
void navilnux_init(void)
{
mem_init();
task_init();
msg_init();
syscall_init();
os_timer_init();
gpio0_init();
os_timer_start();
}
int main(void)
{
irq_init();
irq_disable();
#ifdef CONFIG_FPU
*SCB_CPACR |= (SCB_CPACR_CP10_FULL | SCB_CPACR_CP11_FULL);
#endif
#ifdef CONFIG_DEBUG
dbg_device_init();
dbg_layer = DL_KDB;
#endif
__l4_printf("%s", banner);
run_init_hook(INIT_LEVEL_PLATFORM);
#ifdef CONFIG_SYMMAP
ksym_init();
#endif
sched_init();
memory_init();
syscall_init();
thread_init_subsys();
ktimer_event_init();
#ifdef CONFIG_KPROBES
kprobe_init();
#endif /* CONFIG_KPROBES */
#ifdef CONFIG_KDB
softirq_register(KDB_SOFTIRQ, debug_kdb_handler);
dbg_puts("Press '?' to print KDB menu\n");
#endif
run_init_hook(INIT_LEVEL_KERNEL);
/* Not creating kernel thread here because it corrupts current stack
*/
create_idle_thread();
create_root_thread();
ktimer_event_create(64, ipc_deliver, NULL);
mpu_enable(MPU_ENABLED);
run_init_hook(INIT_LEVEL_LAST);
switch_to_kernel();
/* Not reached */
return 0;
}
/* #if 0 */
int arch_auto_init() {
dbgio_init(); /* Init debug IO and print a banner */
fs_ps2load_init_console();
dbglog(DBG_INFO, "\n--\n");
dbglog(DBG_INFO, banner);
timer_init(); /* Timers */
irq_init(); /* IRQs */
syscall_init(); /* System call interface */
#if 0
hardware_init(); /* DC Hardware init */
#endif
/* Threads */
#if 0
if (__kos_init_flags & INIT_THD_PREEMPT)
thd_init(THD_MODE_PREEMPT);
else
#endif
thd_init(THD_MODE_COOP);
fs_init(); /* VFS */
fs_ramdisk_init(); /* Ramdisk */
fs_romdisk_init(); /* Romdisk */
if (__kos_romdisk != NULL) {
fs_romdisk_mount("/rd", __kos_romdisk, 0);
}
if (fs_ps2load_init() >= 0) {
dbglog(DBG_INFO, "ps2-load console support enabled\n");
}
#if 0
fs_iso9660_init();
fs_vmu_init();
/* Now comes the optional stuff */
if (__kos_init_flags & INIT_IRQ) {
irq_enable(); /* Turn on IRQs */
maple_wait_scan(); /* Wait for the maple scan to complete */
}
if (__kos_init_flags & INIT_NET) {
net_init(); /* Enable networking (and drivers) */
}
/* And one more mandatory thing */
timer_ms_enable();
#endif
return 0;
}
/* This is the C kernel entry point */
void kmain(struct multiboot *mboot_header, addr_t initial_stack)
{
/* Store passed values, and initiate some early things
* We want serial log output as early as possible */
kernel_state_flags=0;
mtboot = mboot_header;
initial_boot_stack = initial_stack;
loader_parse_kernel_elf(mboot_header, &kernel_sections);
#if CONFIG_MODULES
loader_init_kernel_symbols();
#endif
serial_init();
cpu_early_init();
#if CONFIG_MODULES
loader_init_modules();
#endif
syscall_init();
fs_initrd_load(mtboot);
cpu_timer_install(1000);
cpu_processor_init_1();
/* Now get the management stuff going */
printk(1, "[kernel]: Starting system management\n");
mm_init(mtboot);
syslog_init();
parse_kernel_command_line((char *)(addr_t)mtboot->cmdline);
tm_init_multitasking();
dm_init();
fs_init();
net_init();
trace_init();
/* Load the rest... */
printk(KERN_MILE, "[kernel]: Kernel is setup (kv=%d, bpl=%d: ok)\n",
CONFIG_VERSION_NUMBER, BITS_PER_LONG);
printk(KERN_DEBUG, "[kernel]: structure sizes: process=%d bytes, thread=%d bytes, inode=%d bytes\n",
sizeof(struct process), sizeof(struct thread), sizeof(struct inode));
cpu_interrupt_set(1);
sys_setup();
cpu_processor_init_2();
timer_calibrate();
#if CONFIG_SMP
if(boot_cpus)
cpu_boot_all_aps();
#endif
tm_clone(0, __init_entry, 0);
sys_setsid();
kt_kernel_idle_task();
}
void kernel_init(void) {
console_init();
debug("Kernel: Booting");
debug("Kernel: Address 0x%08X~0x%08X, Used %d KB", _kernel_start, _kernel_end, (_kernel_end - _kernel_start + 1023) / 1024);
mm_init();
intr_init();
dev_init();
syscall_init();
process_init();
}
void main(struct multiboot *mboot) {
int rc;
/* init the kmsg buffer and printk */
console_sys_init();
kmsg_init();
console_register(&kmsg_con);
/* arch might want to setup stuff */
arch_early_init();
printk("kmsg: buffer setup!\n");
printk("sys: kernel relocation: 0x%x -> 0x%x size 0x%x\n",
&kernel_base, &kernel_end,
(uintptr_t)&kernel_end - (uintptr_t)&kernel_base);
parse_multiboot(mboot);
paging_fini();
heap_install();
/* arch should finish init now */
arch_late_init();
printk("sys: init done!\n");
drivers_init();
do_mount();
do_test();
syscall_init();
/* wait forever */
asm volatile("mov $0x1337, %eax");
asm volatile("mov $0x1337, %ebx");
asm volatile("mov $0x1337, %ecx");
asm volatile("mov $0x1337, %edx");
start_sched();
panic("finished with main, but no idle task was started\n");
}
int main()
{
//Start video driver (must always be before loading message)
mm_init();
pg_init();
real_init();
video_init();
video_setdriver(video_vgatext_getdriver(),0);
//Put loading message
cli_puts("ArcaneOS Loading...\n");
//Setup kernel
gdt_init();
idt_init();
isr_init();
irq_init();
timer_init();
kb_init();
ui_init();
cpuid_init();
cmos_init();
rtc_init();
acpi_init();
power_init();
mt_init();
syscall_init();
floppy_init();
__asm__ __volatile__ ("sti");
//Enable ACPI
acpi_enable();
//Create thread for ui
mt_create_thread(mt_kernel_process,test,2);
//Endless loop to prevent bugs when all threads are sleeping
for(;;)
__asm__ __volatile__ ("hlt");
}
void main_ap(void)
{
// Load the IDT
idt_load((uintptr_t) &idt_data, IDT_LENGTH);
// Enable LAPIC and calibrate the timer
lapic_setup();
lapic_timer_calibrate();
// Setup stack mapping
kernel_map_stack();
// Setup fast syscall support
syscall_init();
// Signal complete AP startup
++smp_ready_count;
// Wait for main entry barrier, then enter the kernel (or halt)
while (main_entry_barrier == 1);
kernel_enter_ap();
}
int main_loop(struct multiboot_info *boot_info)
{
_kclear();
syscall_init();
module_start = (char*) *((unsigned int*)boot_info->mods_addr);
module_end = *((unsigned int*)(boot_info->mods_addr+4));
_kcolor(BRIGHT_GREEN);
_kputs(DREAMOS_VER);
_kcolor(WHITE);
_kputs(LNG_SITE);
_kcolor(BRIGHT_BLUE);
_kputs(SITEURL);
_kputs("\n");
_kcolor(WHITE);
_kputs("\n");
_kputs(LNG_GDT);
init_gdt();
_kprintOK();
outportb(0xFF, MASTER_PORT_1);
outportb(0xFF, SLAVE_PORT_1);
_kputs(LNG_IDT);
asm("cli");
init_idt();
_kprintOK();
_kputs(LNG_PIC8259);
init_IRQ();
_kprintOK();
printf(LNG_PIT8253);
configure_PIT ();
//_kprintOK();
set_memorysize((boot_info->mem_upper+boot_info->mem_lower)*1024);
init_mem();
asm("sti");
_kprintOK();
init_paging();
_kprintOK();
printf("Memory (upper) amount-> %d kb \n", boot_info->mem_upper);
printf("Memory (lower) amount-> %d kb \n", boot_info->mem_lower);
/* Alloc and fill CPUID structure */
sinfo = kmalloc(sizeof(struct cpuinfo_generic));
get_cpuid (sinfo);
vfs_init();
initfs_init();
if(boot_info->mods_count > 0) printf("Found n. %d Modules\n", boot_info->mods_count);
//printf("Address of module: 0x%x - 0x%x\n", *((unsigned int*)boot_info->mods_addr),module_end-(unsigned int) module_start);
printf("\n");
printf("----\n");
printf(LNG_SHELL);
_kprintOK();
printf("[+] Address: 0x%x\n", &end);
printf("\n");
#ifdef BOCHS_DEBUG
dbg_bochs_print((const unsigned char*)"DreamOS Debug String for Bochs\n");
#endif
shell();
return 0;
}
void main_bsp(void)
{
// Print header
screen_write("Hydrogen v0.2b - http://github.com/farok/H2", 0, 0);
screen_write("Copyright (c) 2012 by Lukas Heidemann", 0, 1);
screen_write("-------------------------------------------------", 0, 2);
// Load the IDT
idt_load(idt_address, IDT_LENGTH);
idt_setup_loader();
// Initialize Hydrogen info tables and parse the multiboot tables
info_init();
multiboot_parse();
// Setup the heap
heap_init();
// Now parse the ACPI tables and analyze the IO APICs
acpi_parse();
ioapic_analyze();
// Find, check and load the kernel binary
kernel_find();
kernel_check();
elf64_load(kernel_binary);
kernel_analyze();
// Initialize interrupt controllers
lapic_detect();
lapic_setup();
ioapic_setup_loader();
pic_setup();
// Calibrate the LAPIC timer
lapic_timer_calibrate();
// Boot APs
info_cpu[lapic_id()].flags |= HY_INFO_CPU_FLAG_BSP;
smp_setup();
// Setup IDT and IOAPIC according to kernel header
idt_setup_kernel();
ioapic_setup_kernel();
// Setup fast syscall support
syscall_init();
// Setup mapping
kernel_map_info();
kernel_map_stack();
kernel_map_idt();
kernel_map_gdt();
// Set free address
info_root->free_paddr = (heap_top + 0xFFF) & ~0xFFF;
// Lower main entry barrier and jump to the kernel entry point
main_entry_barrier = 0;
kernel_enter_bsp();
}
void main(uint32_t magic, struct multiboot_info *mbi,
uintptr_t esp, uintptr_t stack_end)
{
stack_start = esp;
stack_size = stack_end - stack_start;
vga_driver = vga_init();
com_driver = serial_init();
logging_init(vga_driver, com_driver);
assert(magic == MULTIBOOT_MAGIC);
assert(mbi->flags & MULTIBOOT_LOADER);
kprintf(INFO, "\033\012Toutatis kernel booting from %s\033\017\n",
(char *)(mbi->boot_loader_name + (uint32_t)&kernel_voffset));
arch_init();
initrd_init(mbi);
assert(mbi->flags & MULTIBOOT_MEMINFO);
paging_init((mbi->mem_lower + mbi->mem_upper) * 1024);
paging_mark_reserved((uint32_t)mbi - (uint32_t)&kernel_voffset);
assert(mbi->flags & MULTIBOOT_MMAP);
for (mmap_entry_t *mmap = (mmap_entry_t *)(mbi->mmap_addr + (uint32_t)&kernel_voffset);
(uint32_t)mmap < mbi->mmap_addr + (uint32_t)&kernel_voffset + mbi->mmap_length;
mmap = (mmap_entry_t *)((uint32_t)mmap + mmap->size + sizeof(mmap->size))) {
if (mmap->type == 2) {
for (uint64_t i = 0; i < mmap->length; i += FRAME_SIZE) {
paging_mark_reserved((mmap->addr + i) & 0xfffff000);
}
}
}
paging_finalize();
void *p1 = kmalloc(8);
void *p2 = kmalloc(8);
*((char *)p1) = 'a';
kprintf(INFO, "p1 @ 0x%x\n", (uint32_t)p1);
kprintf(INFO, "p2 @ 0x%x\n", (uint32_t)p2);
kfree(p2);
kfree(p1);
void *p3 = kmalloc(16);
kprintf(INFO, "p3 @ 0x%x\n", (uint32_t)p3);
uintptr_t phys;
void *p4 = kmalloc_ap(0x1a0000, &phys);
memset(p4, 0, 0x1a0000);
*((char *)p4) = 'z';
kprintf(INFO, "p4 @ 0x%x phys = %x\n", (uint32_t)p4, phys);
void *p5 = kmalloc(0x02);
kprintf(INFO, "p5 @ 0x%x\n", (uint32_t)p5);
kfree(p5);
kfree(p4);
kfree(p3);
print_mmap(mbi);
syscall_init();
scheduling_init();
keyboard_init();
process_t *proc1 = create_process("Process 1", 1);
process_t *proc2 = create_process("Process 2", 1);
process_t *proc3 = create_process("Process 3", 1);
process_t *procs[] = { proc1, proc2, proc3 };
unsigned int k = 0;
unsigned int off = 0;
for (k = 0; k < 10; ++k) {
if (!create_thread(procs[k % 3], func2, (void *)(off + 80*2), 1, 0, 0)) {
kprintf(INFO, "Oups\n");
stop();
}
if (!create_thread(procs[k % 3], func1, (void *)k, 1, 1, 0)) {
kprintf(INFO, "Oups\n");
stop();
}
off += 2;
}
//create_thread(proc1, func3, (void *)0, 1, 1, 1);
k = 0;
unsigned int i = 0;
off = 0;
for (;;) {
uint16_t *video = (uint16_t *)(0xc00b8000 + 80);
*video = (uint16_t)alph[i++ % sizeof(alph)] | 0x0f00;
if (k % 1 == 0) {
//set_pos(0, 23);
//vga_print_dec(k);
//kprintf(INFO, "mem used: %6x num threads:%3d \n", mem_used(kheap), get_num_threads());
}
/*
if (!create_thread(proc1, func2, (void *)(off + 80*2), 1, 0, 0)) {
kprintf(INFO, "Oups\n");
break;
}
off += 2;
off %= (60 * (25-2));
*/
char c = keyboard_lastchar();
if (c == 'u') {
create_thread(proc1, func1, (void *)5, 1, 1, 0);
} else if (c == 'k') {
create_thread(proc1, func2, (void *)off, 1, 0, 0);
off += 2;
}
++k;
}
serial_terminate();
stop();
}
registers_t *kinit(mboot_info_t *mboot, uint32_t mboot_magic)
{
kdbg_init();
assert(mboot_magic == MBOOT_MAGIC2);
mboot_mod_t *mods = (mboot_mod_t *)(assert_higher(mboot->mods_addr));
kernel_elf_init(mboot);
pmm_init(mboot);
vmm_init(mods[0].mod_end);
idt_init();
tss_init();
register_int_handler(INT_PF, page_fault_handler);
register_int_handler(INT_SCHEDULE, switch_kernel_thread);
scheduler_init();
timer_init(500);
/* vfs_init(); */
syscall_init();
process_init((void(*)(void))&_idle);
tar_header_t *tarfs_location = assert_higher((tar_header_t *)mods[0].mod_start);
debug_enabled = 1;
debug("[info] Mboot flags %x\n", mboot->mods_addr);
debug("[info] Mounting tarfs as root\n");
vfs_init();
vfs_mount("/", tarfs_init(tarfs_location));
vfs_mount("/mnt/tarfs", tarfs_init(tarfs_location));
vfs_mount("/dev/debug", debug_dev_init());
keyboard_init();
fopen("/dev/debug", "w");
fopen("/dev/debug", "w");
/* for(;;); */
/* vfs_mount("/", tarfs_init(tarfs_location)); */
/* keyboard_init(); */
/* vfs_mount("/dev/debug", debug_dev_init()); */
/* fopen("/dev/kbd", "r"); */
/* fopen("/dev/debug", "w"); */
/* fopen("/dev/debug", "w"); */
execve("/bin/init",0,0);
debug("[status]========================\n");
debug("[status] Os5 by Thomas Lovén\n");
debug("[status] Kernel git data: [%s (%s)] %s\n", __kernel_git_hash, (__kernel_git_dirty)?"dirty":"clean", __kernel_git_date);
debug("[status] %s: %s\n", __kernel_git_branch, __kernel_git_message);
debug("[status] Kernel compilation: %s %s\n", __kernel_build_date, __kernel_build_time);
debug("[status]========================\n");
thread_t *init = new_thread((void(*)(void))current->proc->mm.code_entry,1);
init->proc = current->proc;
debug("[status] Kernel booted\n");
return switch_kernel_thread(0);
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry(unsigned long magic, unsigned long addr)
{
multiboot_info_t *mbi;
uint32_t filesys_start_addr;
/* Clear the screen. */
vga_text_clear();
/* Am I booted by a Multiboot-compliant boot loader? */
if(magic != MULTIBOOT_BOOTLOADER_MAGIC) {
printf("Invalid magic number: 0x%#x\n", (unsigned)magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *)addr;
/* Print out the flags. */
printf("flags = 0x%#x\n", (unsigned)mbi->flags);
/* Are mem_* valid? */
if(CHECK_FLAG(mbi->flags, 0))
printf("mem_lower = %uKB, mem_upper = %uKB\n", (unsigned)mbi->mem_lower, (unsigned)mbi->mem_upper);
/* Is boot_device valid? */
if(CHECK_FLAG(mbi->flags, 1))
printf("boot_device = 0x%#x\n", (unsigned)mbi->boot_device);
/* Is the command line passed? */
if(CHECK_FLAG(mbi->flags, 2))
printf("cmdline = %s\n", (char *)mbi->cmdline);
if(CHECK_FLAG(mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
filesys_start_addr = (uint32_t)mod->mod_start;
while(mod_count < mbi->mods_count) {
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i < 16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if(CHECK_FLAG(mbi->flags, 4) && CHECK_FLAG(mbi->flags, 5)) {
printf("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if(CHECK_FLAG(mbi->flags, 5)) {
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned)elf_sec->num, (unsigned)elf_sec->size,
(unsigned)elf_sec->addr, (unsigned)elf_sec->shndx);
}
/* Are mmap_* valid? */
if(CHECK_FLAG(mbi->flags, 6)) {
memory_map_t *mmap;
printf("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned)mbi->mmap_addr,
(unsigned)mbi->mmap_length);
for(mmap = (memory_map_t *)mbi->mmap_addr;
(unsigned long)mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *)((unsigned long)mmap + mmap->size + sizeof(mmap->size)))
printf(" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned)mmap->size,
(unsigned)mmap->base_addr_high,
(unsigned)mmap->base_addr_low,
(unsigned)mmap->type,
(unsigned)mmap->length_high,
(unsigned)mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
/* If kernel got to here, that means everything should be fine with the boot.
* Now we should initialize IDT, PIC, Syscall, paging, devices, filesystem,
* and any other initialization stuff... terminal_init() should be called at
* the very end of the initializations (after sti). */
/* But first, let's clear the screen */
vga_text_clear();
/* Init the IDT */
idt_init();
/* Init the PIC */
i8259_init();
/* Init Syscall */
syscall_init();
/* Init Paging */
paging_init();
/* Init file system */
filesys_init(filesys_start_addr);
/* Init the Keyboard */
keyboard_init();
/* Init the RTC */
rtc_init();
/* Enable interrupts */
sti();
/* booting screen in mode X */
start_up = 3;
set_mode_x();
load_bmp((uint8_t*)"boot", LOAD_FLAG_BOOT);
while(start_up == 3);
set_text_mode();
/* Init the good looking terminal */
terminal_init();
/* wait for a key press to clear the start up screen */
while(start_up == 2);
vga_text_clear();
welcome_and_credit();
while(start_up == 1);
/* Init the status bar for that terminal */
terminal_stat_bar_init();
terminal_clear();
/* Init the PIT */
pit_init();
/* Execute the first program "shell" */
pid_now = 1;
pid_running[0] = 1;
root_shell_flag = 1;
execute((uint8_t*)"shell");
/* Spin (nicely, so we don't chew up cycles) */
asm volatile(".1: hlt; jmp .1;");
}