test

core/clock.c

@@ -0,0 +1,54 @@
+#include <zinnia/clock.h>
+#include <zinnia/compiler.h>
+#include <zinnia/print.h>
+#include <zinnia/spin.h>
+#include <stdatomic.h>
+#include <stdint.h>
+
+static struct clock* active_clock = nullptr;
+static uint64_t counter_base = 0;
+static struct spinlock lock = {};
+
+bool clock_available() {
+    return active_clock != nullptr;
+}
+
+uint64_t clock_get_elapsed_ns() {
+    struct clock* active = atomic_load(&active_clock);
+    if (__unlikely(!active))
+        return 0;
+
+    return atomic_load(&counter_base) + active->get_elapsed_ns(active);
+}
+
+bool clock_switch(struct clock* clock) {
+    spin_lock(&lock);
+
+    if (active_clock) {
+        if (clock->priority <= active_clock->priority) {
+            spin_unlock(&lock);
+            return false;
+        }
+    }
+
+    printf("Switching to clock source \"%s\"\n", clock->name);
+
+    uint64_t elapsed = clock_get_elapsed_ns();
+    counter_base += elapsed;
+
+    active_clock = clock;
+    spin_unlock(&lock);
+    return true;
+}
+
+void clock_spin_ns(uint64_t ns) {
+    if (active_clock == nullptr) {
+        printf("Unable to sleep for %lu ns, no clock available!\n", ns);
+        return;
+    }
+
+    uint64_t target = clock_get_elapsed_ns() + ns;
+    while (clock_get_elapsed_ns() < target) {
+        // TODO: Maybe pause?
+    }
+}

core/console.c

@@ -0,0 +1,43 @@
+#include <zinnia/cmdline.h>
+#include <zinnia/console.h>
+#include <zinnia/print.h>
+#include <string.h>
+
+extern struct console* const __ld_console_start[];
+extern struct console* const __ld_console_end[];
+
+struct console* active = nullptr;
+
+void console_write(const char* buf, size_t len) {
+    if (__likely(active))
+        active->write(active, buf, len);
+}
+
+static void console_setup(const char* value) {
+    if (!value)
+        return;
+
+    // Find a suitable boot console.
+    struct console* const* cur = __ld_console_start;
+    while (cur < __ld_console_end) {
+        if (!strcmp(value, (*cur)->name)) {
+            active = *cur;
+        }
+        cur++;
+    }
+}
+
+CMDLINE_OPTION("console", console_setup);
+
+void console_init() {
+    // If we have no console set and at least one set, use that as a default.
+    if (!active && &__ld_console_start[0] != &__ld_console_end[0])
+        active = __ld_console_start[0];
+
+    if (active) {
+        if (active->init(active) == false)
+            active = nullptr;
+        else
+            printf("Logging on console \"%s\"\n", active->name);
+    }
+}

core/elf.c

@@ -0,0 +1,200 @@
+#include <zinnia/elf.h>
+#include <zinnia/errno.h>
+#include <zinnia/mem/alloc.h>
+#include <zinnia/percpu.h>
+#include <zinnia/pmap.h>
+#include <zinnia/print.h>
+#include <zinnia/sched.h>
+#include <zinnia/utils.h>
+#include <zinnia/vas.h>
+#include <zinnia/vdso.h>
+#include <zinnia/vmo.h>
+#include <assert.h>
+#include <bits/elf.h>
+#include <string.h>
+
+errno_t elf_load(struct exec_info* info, struct task** out) {
+    errno_t status;
+
+    size_t read;
+    struct elf_ehdr ehdr = {};
+    vmo_read(info->file_obj, 0, &ehdr, sizeof(ehdr), &read);
+
+    // Check if the file is an ELF.
+    if (memcmp(ehdr.e_ident, ELF_MAG, sizeof(ELF_MAG)) != 0)
+        return EINVAL;
+    if (ehdr.e_ident[EI_VERSION] != EV_CURRENT)
+        return EINVAL;
+    if (ehdr.e_ident[EI_CLASS] != ELF_ARCH_CLASS)
+        return EINVAL;
+    if (ehdr.e_ident[EI_DATA] != ELF_ARCH_DATA)
+        return EINVAL;
+    if (ehdr.e_machine != ELF_ARCH_MACHINE)
+        return EINVAL;
+    if (ehdr.e_type != ET_EXEC)
+        return EINVAL;
+
+    const size_t page_size = arch_mem_page_size();
+
+    for (size_t i = 0; i < ehdr.e_phnum; i++) {
+        struct elf_phdr phdr = {};
+        vmo_read(info->file_obj, (ehdr.e_phoff + (i * ehdr.e_phentsize)), &phdr, sizeof(phdr), &read);
+        if (phdr.p_type == PT_LOAD) {
+            enum zn_vm_flags prot = 0;
+            if (phdr.p_flags & PF_R)
+                prot |= ZN_VM_MAP_READ;
+            if (phdr.p_flags & PF_W)
+                prot |= ZN_VM_MAP_WRITE;
+            if (phdr.p_flags & PF_X)
+                prot |= ZN_VM_MAP_EXEC;
+
+            assert(phdr.p_offset % phdr.p_align == phdr.p_vaddr % phdr.p_align, "");
+
+            const uintptr_t misalign = phdr.p_vaddr & (page_size - 1);
+            const uintptr_t map_address = phdr.p_vaddr - misalign;
+            const size_t backed_map_size = (phdr.p_filesz + misalign + page_size - 1) & ~(page_size - 1);
+            const size_t total_map_size = (phdr.p_memsz + misalign + page_size - 1) & ~(page_size - 1);
+
+            // Copy the file data into its own mapping.
+            struct paged_vmo* phdr_obj;
+            status = vmo_new_phys(&phdr_obj);
+            if (status)
+                return status;
+
+            status = vmo_copy(&phdr_obj->object, phdr.p_offset, info->file_obj, phdr.p_offset, phdr.p_filesz, nullptr);
+            if (status)
+                return status;
+
+            // We map more than we copied so the rest is filled with zeroed pages.
+            status = vma_map_vmo(info->space, &phdr_obj->object, phdr.p_vaddr, phdr.p_memsz, prot, phdr.p_offset);
+            if (status)
+                return status;
+        }
+    }
+
+    const uintptr_t highest = ((uintptr_t)1 << (mem_high_shift() - 1)) - page_size;
+    const size_t stack_size = 2 * 1024 * 1024; // 2MiB
+    const uintptr_t stack_start = highest - stack_size;
+
+    // Allocate stack.
+    struct paged_vmo* stack;
+    status = vmo_new_phys(&stack);
+    if (status)
+        return status;
+
+    // Fill in stack info.
+    uintptr_t stack_off = stack_size;
+
+    // TODO: Instead of allocating, calculate it on the fly.
+    size_t num_envp = 0;
+    for (const char** ptr = info->envp; *ptr != nullptr; ptr++) {
+        num_envp++;
+    }
+    size_t num_argv = 0;
+    for (const char** ptr = info->argv; *ptr != nullptr; ptr++) {
+        num_argv++;
+    }
+    uintptr_t* envp_offsets = mem_alloc(num_envp * sizeof(uintptr_t), 0);
+    uintptr_t* argv_offsets = mem_alloc(num_argv * sizeof(uintptr_t), 0);
+
+    for (size_t env = 0; env < num_envp; env++) {
+        const char nul = 0;
+        stack_off -= 1;
+        vmo_write(&stack->object, stack_off, &nul, sizeof(nul), nullptr);
+
+        const size_t len = strlen(info->envp[env]);
+        stack_off -= len;
+        vmo_write(&stack->object, stack_off, info->envp[env], len, nullptr);
+
+        envp_offsets[env] = stack_start + stack_off;
+    }
+
+    for (size_t arg = 0; arg < num_argv; arg++) {
+        const char nul = 0;
+        stack_off -= 1;
+        vmo_write(&stack->object, stack_off, &nul, sizeof(nul), nullptr);
+
+        const size_t len = strlen(info->argv[arg]);
+        stack_off -= len;
+        vmo_write(&stack->object, stack_off, info->argv[arg], len, nullptr);
+
+        argv_offsets[arg] = stack_start + stack_off;
+    }
+
+    stack_off = ALIGN_DOWN(stack_off, 16);
+
+    // Align the stack if argc + argv + envp does not add up to 16 byte alignment.
+    if ((1 + num_argv + num_envp) & 1) {
+        stack_off -= sizeof(uintptr_t);
+        uintptr_t zero = 0;
+        vmo_write(&stack->object, stack_off, &zero, sizeof(zero), nullptr);
+    }
+
+    // Add the init handle to the process namespace.
+    zn_handle_t init_handle = ZN_HANDLE_INVALID;
+    if (info->init_handle) {
+        status = namespace_add_desc(info->ns, *info->init_handle, &init_handle);
+        if (status)
+            return status;
+    }
+
+#define WRITE_AUXV(auxv, value) \
+    do { \
+        stack_off -= sizeof(uintptr_t); \
+        uintptr_t auxv_val = value; \
+        vmo_write(&stack->object, stack_off, &auxv_val, sizeof(uintptr_t), nullptr); \
+        stack_off -= sizeof(uintptr_t); \
+        auxv_val = auxv; \
+        vmo_write(&stack->object, stack_off, &auxv_val, sizeof(uintptr_t), nullptr); \
+    } while (0)
+
+    // Write auxiliary values.
+    WRITE_AUXV(AT_NULL, 0);
+    WRITE_AUXV(AT_SECURE, 0);
+    WRITE_AUXV(AT_PHNUM, ehdr.e_phnum);
+    WRITE_AUXV(AT_PHENT, ehdr.e_phentsize);
+    WRITE_AUXV(AT_ENTRY, ehdr.e_entry);
+    WRITE_AUXV(AT_INIT_HANDLE, init_handle);
+
+    // envp pointers.
+    stack_off -= sizeof(uintptr_t);
+    const uintptr_t zero = 0;
+    vmo_write(&stack->object, stack_off, &zero, sizeof(zero), nullptr);
+    for (size_t env = 0; env < num_envp; env++) {
+        stack_off -= sizeof(uintptr_t);
+        vmo_write(&stack->object, stack_off, &envp_offsets[env], sizeof(envp_offsets[env]), nullptr);
+    }
+
+    // argv pointers.
+    stack_off -= sizeof(uintptr_t);
+    vmo_write(&stack->object, stack_off, &zero, sizeof(zero), nullptr);
+    for (size_t arg = 0; arg < num_argv; arg++) {
+        stack_off -= sizeof(uintptr_t);
+        vmo_write(&stack->object, stack_off, &argv_offsets[arg], sizeof(argv_offsets[arg]), nullptr);
+    }
+
+    mem_free(envp_offsets);
+    mem_free(argv_offsets);
+
+    // argc
+    stack_off -= sizeof(uintptr_t);
+    uintptr_t argc = num_argv;
+    vmo_write(&stack->object, stack_off, &argc, sizeof(argc), nullptr);
+
+    status = vma_map_vmo(info->space, &stack->object, stack_start, stack_size, ZN_VM_MAP_READ | ZN_VM_MAP_WRITE, 0);
+    if (status)
+        return status;
+
+    struct task_start_info* start_info = mem_alloc(sizeof(struct task_start_info), 0);
+    start_info->ip = ehdr.e_entry;
+    start_info->sp = highest - stack_size + stack_off;
+    start_info->arg = 0;
+
+    struct task* result;
+    status = task_create(info->argv[0], info->space, info->ns, sched_to_user, (uintptr_t)start_info, &result);
+    if (status)
+        return status;
+
+    *out = result;
+    return 0;
+}

core/futex.c

@@ -0,0 +1,120 @@
+#include <zinnia/errno.h>
+#include <zinnia/futex.h>
+#include <zinnia/percpu.h>
+#include <zinnia/print.h>
+#include <zinnia/sched.h>
+#include <zinnia/spin.h>
+#include <zinnia/usercopy.h>
+
+struct futex_bucket {
+    struct wait_queue wq;
+    uintptr_t key; // Virtual address used as the futex key.
+    bool in_use;
+};
+
+#define FUTEX_BUCKET_COUNT 64
+
+static struct futex_bucket futex_table[FUTEX_BUCKET_COUNT];
+static struct spinlock futex_table_lock;
+
+void futex_init(void) {
+    futex_table_lock = (struct spinlock){0};
+    for (size_t i = 0; i < FUTEX_BUCKET_COUNT; i++) {
+        wait_queue_init(&futex_table[i].wq);
+        futex_table[i].key = 0;
+        futex_table[i].in_use = false;
+    }
+}
+
+static size_t futex_hash(uintptr_t addr) {
+    // Simple hash: mix the address bits and mod by bucket count.
+    addr = (addr >> 2) ^ (addr >> 12);
+    return addr % FUTEX_BUCKET_COUNT;
+}
+
+static struct futex_bucket* futex_bucket_get(uintptr_t addr) {
+    size_t idx = futex_hash(addr);
+    // Linear probing to find a matching or free bucket.
+    for (size_t i = 0; i < FUTEX_BUCKET_COUNT; i++) {
+        size_t slot = (idx + i) % FUTEX_BUCKET_COUNT;
+        struct futex_bucket* b = &futex_table[slot];
+        if (b->in_use && b->key == addr)
+            return b;
+        if (!b->in_use) {
+            b->key = addr;
+            b->in_use = true;
+            return b;
+        }
+    }
+    return nullptr;
+}
+
+errno_t futex_wait(__user int* addr, int expected) {
+    uintptr_t key = (uintptr_t)addr;
+
+    spin_lock(&futex_table_lock);
+
+    // Read the current value at the userspace address.
+    int current;
+    if (!usercopy_read(&current, addr, sizeof(*addr))) {
+        spin_unlock(&futex_table_lock);
+        return EFAULT;
+    }
+
+    // If the value has already changed, don't block.
+    if (current != expected) {
+        spin_unlock(&futex_table_lock);
+        return 0;
+    }
+
+    struct futex_bucket* bucket = futex_bucket_get(key);
+    if (!bucket) {
+        spin_unlock(&futex_table_lock);
+        return ENOMEM;
+    }
+
+    spin_unlock(&futex_table_lock);
+
+    // Block on the bucket's wait queue.
+    struct sched_percpu* sched = &percpu_get()->sched;
+    sched_block(sched, &bucket->wq);
+
+    return 0;
+}
+
+errno_t futex_wake(__user int* addr, int count) {
+    uintptr_t key = (uintptr_t)addr;
+
+    spin_lock(&futex_table_lock);
+
+    size_t idx = futex_hash(key);
+    struct futex_bucket* bucket = nullptr;
+    for (size_t i = 0; i < FUTEX_BUCKET_COUNT; i++) {
+        size_t slot = (idx + i) % FUTEX_BUCKET_COUNT;
+        struct futex_bucket* b = &futex_table[slot];
+        if (b->in_use && b->key == key) {
+            bucket = b;
+            break;
+        }
+        if (!b->in_use)
+            break;
+    }
+
+    if (!bucket) {
+        spin_unlock(&futex_table_lock);
+        return 0; // No waiters, nothing to do.
+    }
+
+    spin_unlock(&futex_table_lock);
+
+    struct sched_percpu* sched = &percpu_get()->sched;
+    if (count == INT32_MAX) {
+        sched_wake_all(sched, &bucket->wq);
+    } else {
+        for (int i = 0; i < count; i++) {
+            sched_wake(sched, &bucket->wq);
+        }
+    }
+
+    return 0;
+}

core/irq.c

@@ -0,0 +1,28 @@
+#include <stdatomic.h>
+#include <zinnia/irq.h>
+#include <zinnia/percpu.h>
+
+void irq_lock() {
+    struct irq_percpu* cpu = &percpu_get()->irq;
+    if (atomic_load_explicit(&cpu->in_interrupt, memory_order_acquire))
+        return;
+
+    arch_irq_set_state(false);
+    atomic_fetch_add_explicit(&percpu_get()->irq.level, 1, memory_order_acq_rel);
+}
+
+void irq_unlock() {
+    struct irq_percpu* cpu = &percpu_get()->irq;
+    if (atomic_load_explicit(&cpu->in_interrupt, memory_order_acquire))
+        return;
+
+    uint32_t old_level = atomic_fetch_sub_explicit(&cpu->level, 1, memory_order_acq_rel);
+    // If it was 1, the new IRQ level is now 0.
+    if (old_level == 1) {
+        arch_irq_set_state(true);
+    }
+}
+
+bool irq_set_interrupted(bool is_interrupted) {
+    return atomic_exchange_explicit(&percpu_get()->irq.in_interrupt, is_interrupted, memory_order_release);
+}

core/meson.build

@@ -0,0 +1,16 @@
+kernel_sources += files(
+    'clock.c',
+    'console.c',
+    'elf.c',
+    'futex.c',
+    'irq.c',
+    'panic.c',
+    'percpu.c',
+    'print.c',
+    'spin.c',
+    'uacpi_glue.c',
+)
+
+if get_option('sched') == 'simple'
+    kernel_sources += files('sched_simple.c')
+endif

core/panic.c

@@ -0,0 +1,32 @@
+#include <zinnia/irq.h>
+#include <zinnia/panic.h>
+#include <zinnia/percpu.h>
+#include <zinnia/print.h>
+#include <stdarg.h>
+
+[[noreturn]]
+void panic(const char* msg, ...) {
+    // TODO: Stop all other CPUs with IPI.
+    arch_irq_set_state(false);
+
+    struct percpu* cpu = percpu_get();
+    struct task* current = cpu->sched.current;
+    printf(
+        "----[ Kernel panic ]----\n"
+        "In task \"%s\" (TID %zu) on CPU %zu!\n",
+        current ? current->name : nullptr,
+        current ? current->id : 0,
+        cpu->id
+    );
+
+    va_list args;
+    va_start(args, msg);
+    kvprintf(msg, args);
+    va_end(args);
+
+    printf("----[ End of panic ]----\n");
+
+    while (1) {
+        arch_irq_wait();
+    }
+}

core/percpu.c

@@ -0,0 +1,14 @@
+#include <zinnia/compiler.h>
+#include <zinnia/percpu.h>
+
+[[__used, __section(".percpu")]]
+struct percpu percpu_bsp = {
+    .self = &percpu_bsp,
+    .id = 0,
+    .online = false,
+};
+
+struct percpu* percpu_new() {
+    // TODO
+    return nullptr;
+}

core/print.c

@@ -0,0 +1,399 @@
+#include <zinnia/clock.h>
+#include <zinnia/console.h>
+#include <zinnia/panic.h>
+#include <zinnia/print.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+static void reverse(char* s) {
+    int i, j;
+    char c;
+
+    for (i = 0, j = strlen(s) - 1; i < j; i++, j--) {
+        c = s[i];
+        s[i] = s[j];
+        s[j] = c;
+    }
+}
+
+static int char_to_digit(char c) {
+    if (c >= '0' && c <= '9')
+        return c - '0';
+    if (c >= 'a' && c <= 'z')
+        return c - 'a' + 10;
+    if (c >= 'A' && c <= 'Z')
+        return c - 'A' + 10;
+    return -1;
+}
+
+unsigned long atolu(const char* str, int base) {
+    unsigned long result = 0;
+
+    if (base == 16 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
+        str += 2;
+    }
+
+    while (*str) {
+        int digit = char_to_digit(*str++);
+        if (digit < 0 || digit >= base)
+            break;
+
+        result = result * base + digit;
+    }
+
+    return result;
+}
+
+long atol(const char* str, int base) {
+    int neg = 0;
+
+    if (*str == '-') {
+        neg = 1;
+        str++;
+    }
+
+    unsigned long val = atolu(str, base);
+    return neg ? -(long)val : (long)val;
+}
+
+char* lutoa(uint64_t value, char* str, int base) {
+    if (base < 2 || base > 36)
+        return nullptr;
+
+    size_t i = 0;
+
+    do {
+        uint64_t digit = value % base;
+        str[i++] = (digit < 10) ? '0' + digit : 'a' + (digit - 10);
+        value /= base;
+    } while (value);
+
+    str[i] = '\0';
+    reverse(str);
+    return str;
+}
+
+char* ltoa(int64_t value, char* str, int base) {
+    if (base < 2 || base > 36)
+        return nullptr;
+
+    uint64_t magnitude;
+    int negative = 0;
+
+    if (value < 0) {
+        negative = 1;
+        magnitude = (uint64_t)(-(value + 1)) + 1;
+        // avoids INT64_MIN overflow
+    } else {
+        magnitude = (uint64_t)value;
+    }
+
+    size_t i = 0;
+
+    do {
+        uint64_t digit = magnitude % base;
+        str[i++] = (digit < 10) ? '0' + digit : 'a' + (digit - 10);
+        magnitude /= base;
+    } while (magnitude);
+
+    if (negative)
+        str[i++] = '-';
+
+    str[i] = '\0';
+    reverse(str);
+    return str;
+}
+
+typedef void (*log_fn_t)(void* ctx, const char* buf, size_t len);
+
+static void do_print(log_fn_t callback, void* ctx, const char* restrict fmt, va_list args) {
+    // Amount of bytes written.
+    int32_t written = 0;
+
+    while (*fmt != '\0') {
+        size_t maxrem = INT32_MAX - written;
+
+        if (fmt[0] != '%' || fmt[1] == '%') {
+            if (fmt[0] == '%')
+                fmt++;
+            size_t amount = 1;
+            while (fmt[amount] && fmt[amount] != '%')
+                amount++;
+            if (maxrem < amount) {
+                return;
+            }
+            callback(ctx, fmt, amount);
+            fmt += amount;
+            written += amount;
+            continue;
+        }
+
+        const char* format_begun_at = fmt++;
+        bool force_sign = false;
+        bool blank_sign = false;
+        bool write_prefix = false;
+        bool pad_zero = false;
+        bool has_width = false;
+        size_t width = 0;
+        bool has_precision = false;
+        size_t precision = 0;
+        size_t size = sizeof(uint32_t);
+        char number[32];
+check_fmt:
+        memset(number, 0, sizeof(number));
+
+        switch (*fmt) {
+        // Flags
+        case '+': {
+            force_sign = true;
+            fmt++;
+            goto check_fmt;
+        }
+        case ' ': {
+            blank_sign = true;
+            fmt++;
+            goto check_fmt;
+        }
+        case '#': {
+            write_prefix = true;
+            fmt++;
+            goto check_fmt;
+        }
+        case '0': {
+            pad_zero = true;
+            fmt++;
+            goto check_fmt;
+        }
+        // Width
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9': {
+            has_width = true;
+            char number[10 + 1] = {0};
+            size_t idx = 0;
+            while (*fmt >= '0' && *fmt <= '9') {
+                number[idx++] = *fmt;
+                fmt++;
+            }
+            width = atolu(number, 10);
+
+            goto check_fmt;
+        }
+        // Precision
+        case '.': {
+            has_precision = true;
+            fmt++;
+            if (*fmt == '*') {
+                precision = (char)va_arg(args, int32_t);
+            } else {
+                char number[10 + 1] = {0};
+                size_t idx = 0;
+                while (*fmt >= '0' && *fmt <= '9') {
+                    number[idx++] = *fmt;
+                    fmt++;
+                }
+                precision = atolu(number, 10);
+            }
+            goto check_fmt;
+        }
+        // Length
+        case 'h': {
+            if (fmt[1] == 'h') {
+                size = sizeof(uint8_t);
+                fmt++;
+            } else
+                size = sizeof(uint16_t);
+            fmt++;
+            goto check_fmt;
+        }
+        case 'l': {
+            // There is no difference between `long int` and `long long int`.
+            if (fmt[1] == 'l')
+                fmt++;
+            fmt++;
+            size = sizeof(uint64_t);
+
+            goto check_fmt;
+        }
+        case 'z': {
+            size = sizeof(size_t);
+            fmt++;
+            goto check_fmt;
+        }
+        // Character
+        case 'c': {
+            char c = (char)va_arg(args, int32_t);
+
+            callback(ctx, &c, sizeof(c));
+
+            written++;
+            fmt++;
+            break;
+        }
+        // String of characters
+        case 's': {
+            const char* str = va_arg(args, const char*);
+            if (!str)
+                str = "(null)";
+            size_t len = 0;
+            if (has_precision)
+                len = strnlen(str, precision);
+            else
+                len = strlen(str);
+
+            callback(ctx, str, len);
+
+            written += len;
+            fmt++;
+            break;
+        }
+        // Signed decimal integer
+        case 'i':
+        case 'd': {
+            switch (size) {
+            case sizeof(int8_t):
+                ltoa((int8_t)va_arg(args, int32_t), number, 10);
+                break;
+            case sizeof(int16_t):
+                ltoa((int16_t)va_arg(args, int32_t), number, 10);
+                break;
+            case sizeof(int32_t):
+                ltoa((int32_t)va_arg(args, int32_t), number, 10);
+                break;
+            default:
+                ltoa(va_arg(args, int64_t), number, 10);
+                break;
+            }
+            goto print_num;
+        }
+        // Unsigned decimal integer
+        case 'u': {
+            switch (size) {
+            case sizeof(uint8_t):
+                lutoa((uint8_t)va_arg(args, uint32_t), number, 10);
+                break;
+            case sizeof(uint16_t):
+                lutoa((uint16_t)va_arg(args, uint32_t), number, 10);
+                break;
+            case sizeof(uint32_t):
+                lutoa(va_arg(args, uint32_t), number, 10);
+                break;
+            case sizeof(uint64_t):
+                lutoa(va_arg(args, uint64_t), number, 10);
+                break;
+            }
+            goto print_num;
+        }
+        // Unsigned hexadecimal integer
+        case 'X':
+        case 'x': {
+            switch (size) {
+            case sizeof(uint8_t):
+                lutoa((uint8_t)va_arg(args, uint32_t), number, 16);
+                break;
+            case sizeof(uint16_t):
+                lutoa((uint16_t)va_arg(args, uint32_t), number, 16);
+                break;
+            case sizeof(uint32_t):
+                lutoa(va_arg(args, uint32_t), number, 16);
+                break;
+            case sizeof(uint64_t):
+                lutoa(va_arg(args, uint64_t), number, 16);
+                break;
+            }
+print_num:
+            size_t len = strlen(number);
+            if (has_precision) {
+                for (size_t i = 0; i < precision - len; i++)
+                    callback(ctx, " ", 1);
+            }
+            if (has_width) {
+                char c = pad_zero ? '0' : ' ';
+
+                // We don't have to pad anything.
+                if (len < width) {
+                    for (size_t i = 0; i < width - len; i++)
+                        callback(ctx, &c, 1);
+                }
+            }
+            if (write_prefix) {
+                callback(ctx, "0x", 2);
+            }
+            if (force_sign) {
+                char c = '+';
+                if (number[0] != '-')
+                    callback(ctx, &c, 1);
+            }
+            if (blank_sign) {
+                char c = ' ';
+                if (number[0] != '-')
+                    callback(ctx, &c, 1);
+            }
+            callback(ctx, number, len);
+
+            written += len;
+            fmt++;
+            break;
+        }
+        // Pointer address
+        case 'p': {
+            const size_t num = va_arg(args, size_t);
+            const size_t buf_size = sizeof(size_t) * 2 + 1;
+            char str[buf_size];
+            lutoa(num, number, 0x10);
+            const size_t len = strlen(number); // Get the length of the final number.
+            for (size_t i = 0; i < buf_size; i++)
+                str[i] = '0';
+            size_t offset = sizeof(str) - len - 1;
+
+            callback(ctx, str, offset);
+            callback(ctx, number, len);
+
+            fmt++;
+            written += len;
+            break;
+        }
+        // The number of characters written so far is stored in the pointed location.
+        case 'n': {
+            int32_t* const ptr = va_arg(args, int32_t*);
+            *ptr = written;
+            fmt++;
+            break;
+        }
+        // No format, just normal text.
+        default: {
+            fmt = format_begun_at;
+            size_t len = strlen(fmt);
+
+            callback(ctx, fmt, len);
+
+            written += len;
+            fmt += len;
+            break;
+        }
+        }
+    }
+}
+
+static void printf_console(void*, const char* msg, size_t len) {
+    console_write(msg, len);
+}
+
+void printf(const char* message, ...) {
+    va_list args;
+    va_start(args, message);
+    do_print(printf_console, nullptr, message, args);
+    va_end(args);
+}
+
+void kvprintf(const char* message, va_list args) {
+    do_print(printf_console, nullptr, message, args);
+}

core/sched_simple.c

@@ -0,0 +1,184 @@
+#include <zinnia/alloc.h>
+#include <zinnia/errno.h>
+#include <zinnia/irq.h>
+#include <zinnia/list.h>
+#include <zinnia/percpu.h>
+#include <zinnia/pmap.h>
+#include <zinnia/print.h>
+#include <zinnia/sched.h>
+#include <zinnia/spin.h>
+#include <zinnia/tailq.h>
+#include <zinnia/vas.h>
+#include <assert.h>
+#include <bits/irq.h>
+#include <stdatomic.h>
+#include <stdint.h>
+#include <string.h>
+
+static void idle_func(uintptr_t) {
+    while (1) {
+        arch_irq_set_state(true);
+        arch_irq_wait();
+    }
+}
+
+void sched_to_user(uintptr_t info_ptr) {
+    struct task_start_info* info = (struct task_start_info*)info_ptr;
+    uintptr_t ip = info->ip;
+    uintptr_t sp = info->sp;
+    uintptr_t arg = info->arg;
+    mem_free(info);
+    arch_sched_jump_to_user(ip, sp, arg);
+}
+
+void sched_to_user_context(uintptr_t ctx) {
+    arch_sched_jump_to_context((struct arch_context*)ctx);
+}
+
+void sched_init(struct sched_percpu* sched) {
+    struct task* idle_task;
+    assert(task_create("idle", &kernel_vas, nullptr, idle_func, 0, &idle_task) == 0, "Unable to create idle task!\n");
+    sched->idle_task = idle_task;
+    sched->current = idle_task;
+
+    tailq_init(&sched->run_queue);
+
+    printf("Scheduler initialized\n");
+}
+
+void sched_add_task(struct sched_percpu* sched, struct task* task) {
+    assert(task != nullptr, "Tried to add NULL to the run queue\n");
+    tailq_insert_tail(&sched->run_queue, task, next);
+}
+
+static struct task* next_task(struct sched_percpu* sched) {
+    struct task* t = tailq_first(&sched->run_queue);
+
+    if (t == nullptr)
+        return sched->idle_task;
+
+    tailq_remove(&sched->run_queue, t, next);
+
+    return t;
+}
+
+static void do_reschedule(struct sched_percpu* sched) {
+    struct task* from = atomic_load_explicit(&sched->current, memory_order_acquire);
+    struct task* to = next_task(sched);
+
+    if (from == to) {
+        irq_unlock();
+        return;
+    }
+
+    atomic_store_explicit(&sched->current, to, memory_order_relaxed);
+
+    pmap_set(&to->space->pmap);
+
+    struct percpu* cpu = percpu_get();
+    from->kernel_stack = cpu->kernel_stack;
+    from->user_stack = cpu->user_stack;
+    cpu->kernel_stack = to->kernel_stack;
+    cpu->user_stack = to->user_stack;
+
+    arch_sched_switch(from, to);
+}
+
+void sched_reschedule(struct sched_percpu* sched) {
+    irq_lock();
+    if (sched->current->state != TASK_STATE_DEAD)
+        sched_add_task(sched, sched->current);
+    do_reschedule(sched);
+}
+
+void sched_yield(struct sched_percpu* sched) {
+    irq_lock();
+    do_reschedule(sched);
+}
+
+errno_t task_create(
+    const char* name,
+    struct vas* space,
+    struct namespace* ns,
+    task_fn_t entry,
+    uintptr_t arg0,
+    struct task** out
+) {
+    if (!out)
+        return EINVAL;
+
+    struct task* new_task = mem_alloc(sizeof(struct task), 0);
+    if (new_task == nullptr)
+        return ENOMEM;
+
+    static size_t last_tid = 0;
+    new_task->id = atomic_fetch_add(&last_tid, 1);
+    new_task->space = space;
+    new_task->namespace = ns;
+    strncpy(new_task->name, name, sizeof(new_task->name));
+
+    // Allocate a kernel stack.
+    new_task->kernel_stack = (uintptr_t)mem_alloc(KERNEL_STACK_SIZE, 0);
+    if (!new_task->kernel_stack)
+        return ENOMEM;
+    new_task->user_stack = 0;
+
+    // Initialize the arch-dependent parts.
+    errno_t s = arch_task_init(&new_task->context, entry, arg0, new_task->kernel_stack + KERNEL_STACK_SIZE, true);
+    if (s != 0)
+        return s;
+
+    *out = new_task;
+    return 0;
+}
+
+void task_entry(task_fn_t entry, uintptr_t arg0) {
+    entry(arg0);
+
+    struct sched_percpu* sched = &percpu_get()->sched;
+    sched->current->state = TASK_STATE_DEAD;
+    sched_yield(sched);
+    panic("unreachable");
+}
+
+void wait_queue_init(struct wait_queue* wq) {
+    tailq_init(&wq->waiters);
+    wq->lock = (struct spinlock){0};
+}
+
+void sched_block(struct sched_percpu* sched, struct wait_queue* wq) {
+    irq_lock();
+    spin_lock(&wq->lock);
+
+    sched->current->state = TASK_STATE_BLOCKED;
+    tailq_insert_tail(&wq->waiters, sched->current, next);
+
+    spin_unlock(&wq->lock);
+    do_reschedule(sched);
+}
+
+void sched_wake(struct sched_percpu* sched, struct wait_queue* wq) {
+    spin_lock(&wq->lock);
+
+    struct task* t = tailq_first(&wq->waiters);
+    if (t != nullptr) {
+        tailq_remove(&wq->waiters, t, next);
+        t->state = TASK_STATE_READY;
+        sched_add_task(sched, t);
+    }
+
+    spin_unlock(&wq->lock);
+}
+
+void sched_wake_all(struct sched_percpu* sched, struct wait_queue* wq) {
+    spin_lock(&wq->lock);
+
+    struct task* t;
+    while ((t = tailq_first(&wq->waiters)) != nullptr) {
+        tailq_remove(&wq->waiters, t, next);
+        t->state = TASK_STATE_READY;
+        sched_add_task(sched, t);
+    }
+
+    spin_unlock(&wq->lock);
+}

core/spin.c

@@ -0,0 +1,15 @@
+#include <zinnia/spin.h>
+#include <stdatomic.h>
+
+void spin_lock(struct spinlock* spin) {
+    uint32_t my = atomic_fetch_add_explicit(&spin->next, 1, memory_order_relaxed);
+
+    while (atomic_load_explicit(&spin->owner, memory_order_acquire) != my) {
+        asm volatile("pause");
+    }
+}
+
+void spin_unlock(struct spinlock* spin) {
+    uint32_t val = atomic_load_explicit(&spin->owner, memory_order_relaxed);
+    atomic_store_explicit(&spin->owner, val + 1, memory_order_release);
+}

core/uacpi_glue.c

@@ -0,0 +1,34 @@
+#include <stdarg.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/status.h>
+#include <uacpi/types.h>
+#include <zinnia/init.h>
+#include <zinnia/mmio.h>
+#include <zinnia/print.h>
+#include <zinnia/utils.h>
+
+uacpi_status uacpi_kernel_get_rsdp(uacpi_phys_addr* out_rsdp_address) {
+    *out_rsdp_address = (uacpi_phys_addr)rsdp_addr;
+    return UACPI_STATUS_OK;
+}
+
+void* uacpi_kernel_map(uacpi_phys_addr addr, uacpi_size len) {
+    return mmio_new(addr, len);
+}
+
+void uacpi_kernel_unmap(void* addr, uacpi_size len) {
+    mmio_free(addr, len);
+}
+
+void uacpi_kernel_log(uacpi_log_level lvl, const uacpi_char* msg, ...) {
+    va_list args;
+    va_start(args, msg);
+
+    kvprintf(msg, args);
+
+    va_end(args);
+}
+
+void uacpi_kernel_vlog(uacpi_log_level lvl, const uacpi_char* msg, uacpi_va_list args) {
+    kvprintf(msg, args);
+}