void blockdev_init(void)
{
block_major = dm_device_register(&__kdev_block);
block_cache_init();
block_buffer_init();
loader_add_kernel_symbol(blockdev_register);
loader_add_kernel_symbol(blockdev_register_partition);
}
void serial_init(void)
{
mutex_create(&serial_m, 0);
arch_serial_init(&serial_debug_port_minor, &serial_enable);
serial_initialized = 1;
serial_console_puts_nolock(0, "[KERNEL]: Started debug serial output.\n");
#if _DBOS_KERNEL_LOADER_MODULES
loader_add_kernel_symbol(serial_console_puts);
loader_add_kernel_symbol(serial_console_puts_nolock);
#endif
}
int module_install(void)
{
#if CONFIG_ARCH == TYPE_ARCH_X86_64
has_intel_aes = primary_cpu->cpuid.features_ecx & (1 << 25) ? 1 : 0;
if(has_intel_aes)
printk(0, "[aes]: intel hardware assisted AES instructions are supported\n");
#endif
loader_add_kernel_symbol(aes_setup_decrypt);
loader_add_kernel_symbol(aes_setup_encrypt);
loader_add_kernel_symbol(aes_decrypt_block);
loader_add_kernel_symbol(aes_encrypt_block);
return 0;
}
void mm_init(struct multiboot *m)
{
printk(KERN_DEBUG, "[mm]: Setting up Memory Management...\n");
arch_mm_virtual_init(&kernel_context);
cpu_interrupt_register_handler (14, &arch_mm_page_fault_handle);
pmm_buddy_init();
process_memorymap(m);
slab_init(MEMMAP_KMALLOC_START, MEMMAP_KMALLOC_END);
set_ksf(KSF_MMU);
/* hey, look at that, we have happy memory times! */
mm_reclaim_init();
for(size_t i=0;i<=(sizeof(struct pagedata) * maximum_page_number) / mm_page_size(1);i++) {
mm_virtual_map(MEMMAP_FRAMECOUNT_START + i * mm_page_size(1),
mm_physical_allocate(mm_page_size(1), true),
PAGE_PRESENT | PAGE_WRITE, mm_page_size(1));
}
frames = (struct pagedata *)(MEMMAP_FRAMECOUNT_START);
printk(0, "[mm]: allocated %d KB for page-frame counting.\n", sizeof(struct pagedata) * maximum_page_number / 1024);
#if CONFIG_MODULES
loader_add_kernel_symbol(slab_kmalloc);
loader_add_kernel_symbol(slab_kfree);
loader_add_kernel_symbol(mm_virtual_map);
loader_add_kernel_symbol(mm_virtual_getmap);
loader_add_kernel_symbol(mm_allocate_dma_buffer);
loader_add_kernel_symbol(mm_free_dma_buffer);
loader_add_kernel_symbol(mm_physical_allocate);
loader_add_kernel_symbol(mm_physical_deallocate);
#endif
}
void acpi_init(void)
{
pmap_create(&acpi_pmap, 0);
struct acpi_rsdp *rsdp = apci_get_RSDP();
if(!rsdp) return;
printk(0, "[acpi]: found valid RSDP structure at %x\n", rsdp);
struct acpi_dt_header *rsdt = (struct acpi_dt_header *)(rsdp->revision ? (addr_t)rsdp->xsdt_addr : (addr_t)rsdp->rsdt_addr);
int pointer_size = (rsdp->revision ? 8 : 4);
const char *sig = (rsdp->revision ? "XSDT" : "RSDT");
addr_t rsdt_v = pmap_get_mapping(&acpi_pmap, (addr_t)rsdt);
int valid = acpi_validate_dt((void *)(rsdt_v), sig);
acpi_rsdt = (void *)rsdt_v;
acpi_rsdt_pt_sz = pointer_size;
if(valid) __acpi_enable=1;
#if CONFIG_MODULES
loader_add_kernel_symbol(acpi_get_table_data);
loader_add_kernel_symbol(find_RSDT_entry);
#endif
}
void acpi_init(void)
{
struct acpi_rsdp *rsdp = apci_get_RSDP();
if(!rsdp)
return;
printk(0, "[ACPI]: found valid RSDP structure at %x\n", rsdp);
struct acpi_dt_header *rsdt = (struct acpi_dt_header *)((rsdp->revision ? (addr_t)rsdp->xsdt_addr : (addr_t)rsdp->rsdt_addr) + PHYS_PAGE_MAP);
int pointer_size = (rsdp->revision ? 8 : 4);
const char *sig = (rsdp->revision ? "XSDT" : "RSDT");
int valid = acpi_validate_dt((void *)(rsdt), sig);
acpi_rsdt = (void *)rsdt;
acpi_rsdt_pt_sz = pointer_size;
if(valid)
__acpi_enable = 1;
#if _DBOS_KERNEL_LOADER_MODULES
loader_add_kernel_symbol(acpi_get_table_data);
loader_add_kernel_symbol(find_RSDT_entry);
#endif
}
void interrupt_init(void)
{
for(int i = 0; i < MAX_INTERRUPTS; i++)
{
timer_create(&interrupt_timers[i], 0);
for(int j = 0; j < MAX_HANDLERS; j++)
{
interrupt_handlers[i][j].fn = 0;
}
}
mutex_create(&isr_lock, 0);
#if _DBOS_KERNEL_LOADER_MODULES
loader_add_kernel_symbol(cpu_interrupt_register_handler);
loader_add_kernel_symbol(cpu_interrupt_unregister_handler);
loader_add_kernel_symbol(cpu_interrupt_schedule_stage2);
loader_do_add_kernel_symbol((addr_t)interrupt_handlers, "interrupt_handlers");
loader_add_kernel_symbol(cpu_interrupt_set);
#endif
}
void tm_init_multitasking(void)
{
printk(KERN_DEBUG, "[sched]: Starting multitasking system...\n");
sysgate_page = mm_physical_allocate(PAGE_SIZE, true);
mm_physical_memcpy((void *)sysgate_page,
(void *)signal_return_injector, MEMMAP_SYSGATE_ADDRESS_SIZE, PHYS_MEMCPY_MODE_DEST);
process_table = hash_create(0, 0, 128);
process_list = linkedlist_create(0, LINKEDLIST_MUTEX);
mutex_create(&process_refs_lock, 0);
mutex_create(&thread_refs_lock, 0);
thread_table = hash_create(0, 0, 128);
struct thread *thread = kmalloc(sizeof(struct thread));
struct process *proc = kernel_process = kmalloc(sizeof(struct process));
proc->refs = 2;
thread->refs = 1;
hash_insert(process_table, &proc->pid, sizeof(proc->pid), &proc->hash_elem, proc);
hash_insert(thread_table, &thread->tid, sizeof(thread->tid), &thread->hash_elem, thread);
linkedlist_insert(process_list, &proc->listnode, proc);
valloc_create(&proc->mmf_valloc, MEMMAP_MMAP_BEGIN, MEMMAP_MMAP_END, PAGE_SIZE, 0);
linkedlist_create(&proc->threadlist, 0);
mutex_create(&proc->map_lock, 0);
mutex_create(&proc->stacks_lock, 0);
mutex_create(&proc->fdlock, 0);
hash_create(&proc->files, HASH_LOCKLESS, 64);
proc->magic = PROCESS_MAGIC;
blocklist_create(&proc->waitlist, 0, "process-waitlist");
mutex_create(&proc->fdlock, 0);
memcpy(&proc->vmm_context, &kernel_context, sizeof(kernel_context));
thread->process = proc; /* we have to do this early, so that the vmm system can use the lock... */
thread->state = THREADSTATE_RUNNING;
thread->magic = THREAD_MAGIC;
workqueue_create(&thread->resume_work, 0);
thread->kernel_stack = (addr_t)&initial_kernel_stack;
spinlock_create(&thread->status_lock);
primary_cpu->active_queue = tqueue_create(0, 0);
primary_cpu->idle_thread = thread;
primary_cpu->numtasks=1;
ticker_create(&primary_cpu->ticker, 0);
workqueue_create(&primary_cpu->work, 0);
tm_thread_add_to_process(thread, proc);
tm_thread_add_to_cpu(thread, primary_cpu);
atomic_fetch_add_explicit(&running_processes, 1, memory_order_relaxed);
atomic_fetch_add_explicit(&running_threads, 1, memory_order_relaxed);
set_ksf(KSF_THREADING);
*(struct thread **)(thread->kernel_stack) = thread;
primary_cpu->flags |= CPU_RUNNING;
#if CONFIG_MODULES
loader_add_kernel_symbol(tm_thread_delay_sleep);
loader_add_kernel_symbol(tm_thread_delay);
loader_add_kernel_symbol(tm_timing_get_microseconds);
loader_add_kernel_symbol(tm_thread_set_state);
loader_add_kernel_symbol(tm_thread_exit);
loader_add_kernel_symbol(tm_thread_poke);
loader_add_kernel_symbol(tm_thread_block);
loader_add_kernel_symbol(tm_thread_got_signal);
loader_add_kernel_symbol(tm_thread_unblock);
loader_add_kernel_symbol(tm_blocklist_wakeall);
loader_add_kernel_symbol(kthread_create);
loader_add_kernel_symbol(kthread_wait);
loader_add_kernel_symbol(kthread_join);
loader_add_kernel_symbol(kthread_kill);
loader_add_kernel_symbol(tm_schedule);
loader_add_kernel_symbol(arch_tm_get_current_thread);
#endif
}
