接着上个

clks.local.bak/include/clks/audio.h

@@ -0,0 +1,12 @@
+#ifndef CLKS_AUDIO_H
+#define CLKS_AUDIO_H
+
+#include <clks/types.h>
+
+void clks_audio_init(void);
+clks_bool clks_audio_available(void);
+clks_bool clks_audio_play_tone(u64 hz, u64 ticks);
+void clks_audio_stop(void);
+u64 clks_audio_play_count(void);
+
+#endif

clks.local.bak/include/clks/boot.h

@@ -0,0 +1,14 @@
+#ifndef CLKS_BOOT_H
+#define CLKS_BOOT_H
+
+#include <clks/limine.h>
+#include <clks/types.h>
+
+clks_bool clks_boot_base_revision_supported(void);
+const struct limine_framebuffer *clks_boot_get_framebuffer(void);
+const struct limine_memmap_response *clks_boot_get_memmap(void);
+const struct limine_file *clks_boot_get_executable_file(void);
+u64 clks_boot_get_module_count(void);
+const struct limine_file *clks_boot_get_module(u64 index);
+
+#endif

clks.local.bak/include/clks/compiler.h

@@ -0,0 +1,17 @@
+#ifndef CLKS_COMPILER_H
+#define CLKS_COMPILER_H
+
+#define CLKS_USED __attribute__((used))
+#define CLKS_NORETURN __attribute__((noreturn))
+#define CLKS_PACKED __attribute__((packed))
+#define CLKS_ALIGN(N) __attribute__((aligned(N)))
+
+#if defined(CLKS_ARCH_X86_64) && defined(CLKS_ARCH_AARCH64)
+#error "Only one architecture can be selected"
+#endif
+
+#if !defined(CLKS_ARCH_X86_64) && !defined(CLKS_ARCH_AARCH64)
+#error "Missing architecture define: CLKS_ARCH_X86_64 or CLKS_ARCH_AARCH64"
+#endif
+
+#endif

clks.local.bak/include/clks/cpu.h

@@ -0,0 +1,24 @@
+#ifndef CLKS_CPU_H
+#define CLKS_CPU_H
+
+#include <clks/compiler.h>
+
+static inline void clks_cpu_pause(void) {
+#if defined(CLKS_ARCH_X86_64)
+    __asm__ volatile("pause");
+#elif defined(CLKS_ARCH_AARCH64)
+    __asm__ volatile("yield");
+#endif
+}
+
+static inline CLKS_NORETURN void clks_cpu_halt_forever(void) {
+    for (;;) {
+#if defined(CLKS_ARCH_X86_64)
+        __asm__ volatile("hlt");
+#elif defined(CLKS_ARCH_AARCH64)
+        __asm__ volatile("wfe");
+#endif
+    }
+}
+
+#endif

clks.local.bak/include/clks/desktop.h

@@ -0,0 +1,10 @@
+#ifndef CLKS_DESKTOP_H
+#define CLKS_DESKTOP_H
+
+#include <clks/types.h>
+
+void clks_desktop_init(void);
+void clks_desktop_tick(u64 tick);
+clks_bool clks_desktop_ready(void);
+
+#endif

clks.local.bak/include/clks/disk.h

@@ -0,0 +1,38 @@
+#ifndef CLKS_DISK_H
+#define CLKS_DISK_H
+
+#include <clks/types.h>
+
+#define CLKS_DISK_SECTOR_SIZE 512ULL
+#define CLKS_DISK_PATH_MAX 192U
+#define CLKS_DISK_NODE_FILE 1ULL
+#define CLKS_DISK_NODE_DIR 2ULL
+
+void clks_disk_init(void);
+
+clks_bool clks_disk_present(void);
+u64 clks_disk_size_bytes(void);
+u64 clks_disk_sector_count(void);
+
+clks_bool clks_disk_read_sector(u64 lba, void *out_sector);
+clks_bool clks_disk_write_sector(u64 lba, const void *sector_data);
+
+clks_bool clks_disk_is_formatted_fat32(void);
+clks_bool clks_disk_format_fat32(const char *label);
+
+clks_bool clks_disk_mount(const char *mount_path);
+clks_bool clks_disk_is_mounted(void);
+const char *clks_disk_mount_path(void);
+clks_bool clks_disk_path_in_mount(const char *path);
+
+clks_bool clks_disk_stat(const char *path, u64 *out_type, u64 *out_size);
+const void *clks_disk_read_all(const char *path, u64 *out_size);
+u64 clks_disk_count_children(const char *dir_path);
+clks_bool clks_disk_get_child_name(const char *dir_path, u64 index, char *out_name, usize out_name_size);
+clks_bool clks_disk_mkdir(const char *path);
+clks_bool clks_disk_write_all(const char *path, const void *data, u64 size);
+clks_bool clks_disk_append(const char *path, const void *data, u64 size);
+clks_bool clks_disk_remove(const char *path);
+u64 clks_disk_node_count(void);
+
+#endif

clks.local.bak/include/clks/driver.h

@@ -0,0 +1,36 @@
+#ifndef CLKS_DRIVER_H
+#define CLKS_DRIVER_H
+
+#include <clks/types.h>
+
+#define CLKS_DRIVER_NAME_MAX 32U
+
+enum clks_driver_kind {
+    CLKS_DRIVER_KIND_BUILTIN_CHAR = 1,
+    CLKS_DRIVER_KIND_BUILTIN_VIDEO = 2,
+    CLKS_DRIVER_KIND_BUILTIN_TTY = 3,
+    CLKS_DRIVER_KIND_ELF = 4,
+    CLKS_DRIVER_KIND_BUILTIN_AUDIO = 5,
+};
+
+enum clks_driver_state {
+    CLKS_DRIVER_STATE_OFFLINE = 0,
+    CLKS_DRIVER_STATE_READY = 1,
+    CLKS_DRIVER_STATE_FAILED = 2,
+};
+
+struct clks_driver_info {
+    char name[CLKS_DRIVER_NAME_MAX];
+    enum clks_driver_kind kind;
+    enum clks_driver_state state;
+    clks_bool from_elf;
+    u64 image_size;
+    u64 elf_entry;
+};
+
+void clks_driver_init(void);
+u64 clks_driver_count(void);
+u64 clks_driver_elf_count(void);
+clks_bool clks_driver_get(u64 index, struct clks_driver_info *out_info);
+
+#endif

clks.local.bak/include/clks/elf64.h

@@ -0,0 +1,40 @@
+#ifndef CLKS_ELF64_H
+#define CLKS_ELF64_H
+
+#include <clks/types.h>
+
+#define CLKS_ELF64_MAX_SEGMENTS 16U
+
+#define CLKS_ELF64_PT_LOAD 1U
+
+struct clks_elf64_info {
+    u64 entry;
+    u16 phnum;
+    u16 loadable_segments;
+    u64 total_load_memsz;
+};
+
+struct clks_elf64_loaded_segment {
+    void *base;
+    u64 vaddr;
+    u64 memsz;
+    u64 filesz;
+    u32 flags;
+};
+
+struct clks_elf64_loaded_image {
+    u64 entry;
+    void *image_base;
+    u64 image_size;
+    u64 image_vaddr_base;
+    u16 segment_count;
+    struct clks_elf64_loaded_segment segments[CLKS_ELF64_MAX_SEGMENTS];
+};
+
+clks_bool clks_elf64_validate(const void *image, u64 size);
+clks_bool clks_elf64_inspect(const void *image, u64 size, struct clks_elf64_info *out_info);
+clks_bool clks_elf64_load(const void *image, u64 size, struct clks_elf64_loaded_image *out_loaded);
+void clks_elf64_unload(struct clks_elf64_loaded_image *loaded);
+void *clks_elf64_entry_pointer(const struct clks_elf64_loaded_image *loaded, u64 entry);
+
+#endif

clks.local.bak/include/clks/elfrunner.h

@@ -0,0 +1,9 @@
+#ifndef CLKS_ELFRUNNER_H
+#define CLKS_ELFRUNNER_H
+
+#include <clks/types.h>
+
+void clks_elfrunner_init(void);
+clks_bool clks_elfrunner_probe_kernel_executable(void);
+
+#endif

clks.local.bak/include/clks/exec.h

@@ -0,0 +1,80 @@
+#ifndef CLKS_EXEC_H
+#define CLKS_EXEC_H
+
+#include <clks/types.h>
+
+#define CLKS_EXEC_PROC_PATH_MAX 192U
+
+#define CLKS_EXEC_PROC_STATE_UNUSED 0ULL
+#define CLKS_EXEC_PROC_STATE_PENDING 1ULL
+#define CLKS_EXEC_PROC_STATE_RUNNING 2ULL
+#define CLKS_EXEC_PROC_STATE_EXITED 3ULL
+#define CLKS_EXEC_PROC_STATE_STOPPED 4ULL
+
+#define CLKS_EXEC_SIGNAL_KILL 9ULL
+#define CLKS_EXEC_SIGNAL_TERM 15ULL
+#define CLKS_EXEC_SIGNAL_CONT 18ULL
+#define CLKS_EXEC_SIGNAL_STOP 19ULL
+
+struct clks_exec_proc_snapshot {
+    u64 pid;
+    u64 ppid;
+    u64 state;
+    u64 started_tick;
+    u64 exited_tick;
+    u64 exit_status;
+    u64 runtime_ticks;
+    u64 mem_bytes;
+    u64 tty_index;
+    u64 last_signal;
+    u64 last_fault_vector;
+    u64 last_fault_error;
+    u64 last_fault_rip;
+    char path[CLKS_EXEC_PROC_PATH_MAX];
+};
+
+void clks_exec_init(void);
+clks_bool clks_exec_run_path(const char *path, u64 *out_status);
+clks_bool clks_exec_run_pathv(const char *path, const char *argv_line, const char *env_line, u64 *out_status);
+clks_bool clks_exec_run_pathv_io(const char *path, const char *argv_line, const char *env_line, u64 stdin_fd,
+                                 u64 stdout_fd, u64 stderr_fd, u64 *out_status);
+clks_bool clks_exec_spawn_path(const char *path, u64 *out_pid);
+clks_bool clks_exec_spawn_pathv(const char *path, const char *argv_line, const char *env_line, u64 *out_pid);
+u64 clks_exec_wait_pid(u64 pid, u64 *out_status);
+clks_bool clks_exec_request_exit(u64 status);
+u64 clks_exec_fd_open(const char *path, u64 flags, u64 mode);
+u64 clks_exec_fd_read(u64 fd, void *out_buffer, u64 size);
+u64 clks_exec_fd_write(u64 fd, const void *buffer, u64 size);
+u64 clks_exec_fd_close(u64 fd);
+u64 clks_exec_fd_dup(u64 fd);
+u64 clks_exec_dl_open(const char *path);
+u64 clks_exec_dl_close(u64 handle);
+u64 clks_exec_dl_sym(u64 handle, const char *symbol);
+u64 clks_exec_current_pid(void);
+u32 clks_exec_current_tty(void);
+u64 clks_exec_current_argc(void);
+clks_bool clks_exec_copy_current_argv(u64 index, char *out_value, usize out_size);
+u64 clks_exec_current_envc(void);
+clks_bool clks_exec_copy_current_env(u64 index, char *out_value, usize out_size);
+u64 clks_exec_current_signal(void);
+u64 clks_exec_current_fault_vector(void);
+u64 clks_exec_current_fault_error(void);
+u64 clks_exec_current_fault_rip(void);
+u64 clks_exec_proc_count(void);
+clks_bool clks_exec_proc_pid_at(u64 index, u64 *out_pid);
+clks_bool clks_exec_proc_snapshot(u64 pid, struct clks_exec_proc_snapshot *out_snapshot);
+u64 clks_exec_proc_kill(u64 pid, u64 signal);
+u64 clks_exec_force_stop_tty_running_process(u32 tty_index, u64 *out_pid);
+clks_bool clks_exec_try_unwind_signaled_process(u64 interrupted_rip, u64 *io_rip, u64 *io_rdi, u64 *io_rsi);
+clks_bool clks_exec_handle_exception(u64 vector, u64 error_code, u64 rip, u64 *io_rip, u64 *io_rdi, u64 *io_rsi);
+u64 clks_exec_sleep_ticks(u64 ticks);
+u64 clks_exec_yield(void);
+void clks_exec_tick(u64 tick);
+u64 clks_exec_request_count(void);
+u64 clks_exec_success_count(void);
+clks_bool clks_exec_is_running(void);
+clks_bool clks_exec_current_path_is_user(void);
+clks_bool clks_exec_current_user_ptr_readable(u64 addr, u64 size);
+clks_bool clks_exec_current_user_ptr_writable(u64 addr, u64 size);
+
+#endif

clks.local.bak/include/clks/framebuffer.h

@@ -0,0 +1,31 @@
+#ifndef CLKS_FRAMEBUFFER_H
+#define CLKS_FRAMEBUFFER_H
+
+#include <clks/limine.h>
+#include <clks/types.h>
+
+struct clks_framebuffer_info {
+    u32 width;
+    u32 height;
+    u32 pitch;
+    u16 bpp;
+};
+
+void clks_fb_init(const struct limine_framebuffer *fb);
+clks_bool clks_fb_ready(void);
+struct clks_framebuffer_info clks_fb_info(void);
+void clks_fb_clear(u32 rgb);
+void clks_fb_scroll_up(u32 pixel_rows, u32 fill_rgb);
+void clks_fb_draw_pixel(u32 x, u32 y, u32 rgb);
+clks_bool clks_fb_read_pixel(u32 x, u32 y, u32 *out_rgb);
+void clks_fb_fill_rect(u32 x, u32 y, u32 width, u32 height, u32 rgb);
+#define CLKS_FB_STYLE_BOLD 0x1U
+#define CLKS_FB_STYLE_UNDERLINE 0x2U
+
+void clks_fb_draw_char(u32 x, u32 y, char ch, u32 fg_rgb, u32 bg_rgb);
+void clks_fb_draw_char_styled(u32 x, u32 y, char ch, u32 fg_rgb, u32 bg_rgb, u32 style_flags);
+clks_bool clks_fb_load_psf_font(const void *blob, u64 blob_size);
+u32 clks_fb_cell_width(void);
+u32 clks_fb_cell_height(void);
+
+#endif

clks.local.bak/include/clks/fs.h

@@ -0,0 +1,30 @@
+#ifndef CLKS_FS_H
+#define CLKS_FS_H
+
+#include <clks/types.h>
+
+enum clks_fs_node_type {
+    CLKS_FS_NODE_FILE = 1,
+    CLKS_FS_NODE_DIR = 2,
+};
+
+struct clks_fs_node_info {
+    enum clks_fs_node_type type;
+    u64 size;
+};
+
+void clks_fs_init(void);
+clks_bool clks_fs_is_ready(void);
+clks_bool clks_fs_stat(const char *path, struct clks_fs_node_info *out_info);
+const void *clks_fs_read_all(const char *path, u64 *out_size);
+u64 clks_fs_count_children(const char *dir_path);
+clks_bool clks_fs_get_child_name(const char *dir_path, u64 index, char *out_name, usize out_name_size);
+
+clks_bool clks_fs_mkdir(const char *path);
+clks_bool clks_fs_write_all(const char *path, const void *data, u64 size);
+clks_bool clks_fs_append(const char *path, const void *data, u64 size);
+clks_bool clks_fs_remove(const char *path);
+
+u64 clks_fs_node_count(void);
+
+#endif

clks.local.bak/include/clks/heap.h

@@ -0,0 +1,19 @@
+#ifndef CLKS_HEAP_H
+#define CLKS_HEAP_H
+
+#include <clks/types.h>
+
+struct clks_heap_stats {
+    usize total_bytes;
+    usize used_bytes;
+    usize free_bytes;
+    u64 alloc_count;
+    u64 free_count;
+};
+
+void clks_heap_init(void);
+void *clks_kmalloc(usize size);
+void clks_kfree(void *ptr);
+struct clks_heap_stats clks_heap_get_stats(void);
+
+#endif

clks.local.bak/include/clks/interrupts.h

@@ -0,0 +1,9 @@
+#ifndef CLKS_INTERRUPTS_H
+#define CLKS_INTERRUPTS_H
+
+#include <clks/types.h>
+
+void clks_interrupts_init(void);
+u64 clks_interrupts_timer_ticks(void);
+
+#endif

clks.local.bak/include/clks/kelf.h

@@ -0,0 +1,13 @@
+#ifndef CLKS_KELF_H
+#define CLKS_KELF_H
+
+#include <clks/types.h>
+
+typedef u64 (*clks_kelf_entry_fn)(u64 tick, u64 run_count);
+
+void clks_kelf_init(void);
+void clks_kelf_tick(u64 tick);
+u64 clks_kelf_count(void);
+u64 clks_kelf_total_runs(void);
+
+#endif

clks.local.bak/include/clks/kernel.h

@@ -0,0 +1,6 @@
+#ifndef CLKS_KERNEL_H
+#define CLKS_KERNEL_H
+
+void clks_kernel_main(void);
+
+#endif

clks.local.bak/include/clks/keyboard.h

@@ -0,0 +1,31 @@
+#ifndef CLKS_KEYBOARD_H
+#define CLKS_KEYBOARD_H
+
+#include <clks/types.h>
+
+#define CLKS_KEY_LEFT ((char)0x01)
+#define CLKS_KEY_RIGHT ((char)0x02)
+#define CLKS_KEY_UP ((char)0x03)
+#define CLKS_KEY_DOWN ((char)0x04)
+#define CLKS_KEY_HOME ((char)0x05)
+#define CLKS_KEY_END ((char)0x06)
+#define CLKS_KEY_DELETE ((char)0x07)
+#define CLKS_KEY_SELECT_ALL ((char)0x10)
+#define CLKS_KEY_COPY ((char)0x11)
+#define CLKS_KEY_PASTE ((char)0x12)
+#define CLKS_KEY_SHIFT_LEFT ((char)0x13)
+#define CLKS_KEY_SHIFT_RIGHT ((char)0x14)
+#define CLKS_KEY_SHIFT_HOME ((char)0x15)
+#define CLKS_KEY_SHIFT_END ((char)0x16)
+
+void clks_keyboard_init(void);
+void clks_keyboard_handle_scancode(u8 scancode);
+u64 clks_keyboard_hotkey_switch_count(void);
+clks_bool clks_keyboard_pop_char(char *out_ch);
+clks_bool clks_keyboard_pop_char_for_tty(u32 tty_index, char *out_ch);
+u64 clks_keyboard_buffered_count(void);
+u64 clks_keyboard_drop_count(void);
+u64 clks_keyboard_push_count(void);
+u64 clks_keyboard_pop_count(void);
+
+#endif

clks.local.bak/include/clks/limine.h

@@ -0,0 +1,135 @@
+#ifndef CLKS_LIMINE_H
+#define CLKS_LIMINE_H
+
+#include <clks/types.h>
+
+#define LIMINE_COMMON_MAGIC 0xc7b1dd30df4c8b88ULL
+#define LIMINE_REQUEST_MAGIC 0x0a82e883a194f07bULL
+
+#define LIMINE_REQUESTS_START_MARKER                                                                                   \
+    { 0xf6b8f4b39de7d1aeULL, 0xfab91a6940fcb9cfULL }
+
+#define LIMINE_REQUESTS_END_MARKER                                                                                     \
+    { 0xadc0e0531bb10d03ULL, 0x9572709f31764c62ULL }
+
+#define LIMINE_BASE_REVISION(N)                                                                                        \
+    { 0xf9562b2d5c95a6c8ULL, 0x6a7b384944536bdcULL, (N) }
+
+#define LIMINE_FRAMEBUFFER_REQUEST                                                                                     \
+    { LIMINE_COMMON_MAGIC, LIMINE_REQUEST_MAGIC, 0x9d5827dcd881dd75ULL, 0xa3148604f6fab11bULL }
+
+#define LIMINE_MEMMAP_REQUEST                                                                                          \
+    { LIMINE_COMMON_MAGIC, LIMINE_REQUEST_MAGIC, 0x67cf3d9d378a806fULL, 0xe304acdfc50c3c62ULL }
+
+#define LIMINE_EXECUTABLE_FILE_REQUEST                                                                                 \
+    { LIMINE_COMMON_MAGIC, LIMINE_REQUEST_MAGIC, 0xad97e90e83f1ed67ULL, 0x31eb5d1c5ff23b69ULL }
+
+#define LIMINE_MODULE_REQUEST                                                                                          \
+    { LIMINE_COMMON_MAGIC, LIMINE_REQUEST_MAGIC, 0x3e7e279702be32afULL, 0xca1c4f3bd1280ceeULL }
+
+#define LIMINE_MEMMAP_USABLE 0ULL
+#define LIMINE_MEMMAP_RESERVED 1ULL
+#define LIMINE_MEMMAP_ACPI_RECLAIMABLE 2ULL
+#define LIMINE_MEMMAP_ACPI_NVS 3ULL
+#define LIMINE_MEMMAP_BAD_MEMORY 4ULL
+#define LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE 5ULL
+#define LIMINE_MEMMAP_EXECUTABLE_AND_MODULES 6ULL
+#define LIMINE_MEMMAP_FRAMEBUFFER 7ULL
+#define LIMINE_MEMMAP_RESERVED_MAPPED 8ULL
+
+struct limine_uuid {
+    u32 a;
+    u16 b;
+    u16 c;
+    u8 d[8];
+};
+
+struct limine_file {
+    u64 revision;
+    void *address;
+    u64 size;
+    char *path;
+    char *string;
+    u32 media_type;
+    u32 unused;
+    u32 tftp_ip;
+    u32 tftp_port;
+    u32 partition_index;
+    u32 mbr_disk_id;
+    struct limine_uuid gpt_disk_uuid;
+    struct limine_uuid gpt_part_uuid;
+    struct limine_uuid part_uuid;
+};
+
+struct limine_framebuffer {
+    void *address;
+    u64 width;
+    u64 height;
+    u64 pitch;
+    u16 bpp;
+    u8 memory_model;
+    u8 red_mask_size;
+    u8 red_mask_shift;
+    u8 green_mask_size;
+    u8 green_mask_shift;
+    u8 blue_mask_size;
+    u8 blue_mask_shift;
+    u8 unused[7];
+    u64 edid_size;
+    void *edid;
+};
+
+struct limine_framebuffer_response {
+    u64 revision;
+    u64 framebuffer_count;
+    struct limine_framebuffer **framebuffers;
+};
+
+struct limine_framebuffer_request {
+    u64 id[4];
+    u64 revision;
+    struct limine_framebuffer_response *response;
+};
+
+struct limine_memmap_entry {
+    u64 base;
+    u64 length;
+    u64 type;
+};
+
+struct limine_memmap_response {
+    u64 revision;
+    u64 entry_count;
+    struct limine_memmap_entry **entries;
+};
+
+struct limine_memmap_request {
+    u64 id[4];
+    u64 revision;
+    struct limine_memmap_response *response;
+};
+
+struct limine_executable_file_response {
+    u64 revision;
+    struct limine_file *executable_file;
+};
+
+struct limine_executable_file_request {
+    u64 id[4];
+    u64 revision;
+    struct limine_executable_file_response *response;
+};
+
+struct limine_module_response {
+    u64 revision;
+    u64 module_count;
+    struct limine_file **modules;
+};
+
+struct limine_module_request {
+    u64 id[4];
+    u64 revision;
+    struct limine_module_response *response;
+};
+
+#endif

clks.local.bak/include/clks/log.h

@@ -0,0 +1,19 @@
+#ifndef CLKS_LOG_H
+#define CLKS_LOG_H
+
+#include <clks/types.h>
+
+enum clks_log_level {
+    CLKS_LOG_DEBUG = 0,
+    CLKS_LOG_INFO = 1,
+    CLKS_LOG_WARN = 2,
+    CLKS_LOG_ERROR = 3,
+};
+
+void clks_log(enum clks_log_level level, const char *tag, const char *message);
+void clks_log_hex(enum clks_log_level level, const char *tag, const char *label, u64 value);
+
+u64 clks_log_journal_count(void);
+clks_bool clks_log_journal_read(u64 index_from_oldest, char *out_line, usize out_line_size);
+
+#endif

clks.local.bak/include/clks/mouse.h

@@ -0,0 +1,25 @@
+#ifndef CLKS_MOUSE_H
+#define CLKS_MOUSE_H
+
+#include <clks/types.h>
+
+#define CLKS_MOUSE_BTN_LEFT 0x01U
+#define CLKS_MOUSE_BTN_RIGHT 0x02U
+#define CLKS_MOUSE_BTN_MIDDLE 0x04U
+
+struct clks_mouse_state {
+    i32 x;
+    i32 y;
+    u8 buttons;
+    u64 packet_count;
+    clks_bool ready;
+};
+
+void clks_mouse_init(void);
+void clks_mouse_handle_byte(u8 data_byte);
+void clks_mouse_snapshot(struct clks_mouse_state *out_state);
+clks_bool clks_mouse_ready(void);
+u64 clks_mouse_packet_count(void);
+u64 clks_mouse_drop_count(void);
+
+#endif

clks.local.bak/include/clks/panic.h

@@ -0,0 +1,10 @@
+#ifndef CLKS_PANIC_H
+#define CLKS_PANIC_H
+
+#include <clks/compiler.h>
+#include <clks/types.h>
+
+CLKS_NORETURN void clks_panic(const char *reason);
+CLKS_NORETURN void clks_panic_exception(const char *name, u64 vector, u64 error_code, u64 rip, u64 rbp, u64 rsp);
+
+#endif

clks.local.bak/include/clks/panic_qr.h

@@ -0,0 +1,19 @@
+#ifndef CLKS_PANIC_QR_H
+#define CLKS_PANIC_QR_H
+
+#include <clks/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+clks_bool clks_panic_qr_prepare(void);
+clks_bool clks_panic_qr_show(void);
+u64 clks_panic_qr_total_lines(void);
+u64 clks_panic_qr_dropped_lines(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

clks.local.bak/include/clks/pmm.h

@@ -0,0 +1,21 @@
+#ifndef CLKS_PMM_H
+#define CLKS_PMM_H
+
+#include <clks/limine.h>
+#include <clks/types.h>
+
+#define CLKS_PAGE_SIZE 4096ULL
+
+struct clks_pmm_stats {
+    u64 managed_pages;
+    u64 free_pages;
+    u64 used_pages;
+    u64 dropped_pages;
+};
+
+void clks_pmm_init(const struct limine_memmap_response *memmap);
+u64 clks_pmm_alloc_page(void);
+void clks_pmm_free_page(u64 phys_addr);
+struct clks_pmm_stats clks_pmm_get_stats(void);
+
+#endif

clks.local.bak/include/clks/ramdisk.h

@@ -0,0 +1,24 @@
+#ifndef CLKS_RAMDISK_H
+#define CLKS_RAMDISK_H
+
+#include <clks/types.h>
+
+#define CLKS_RAMDISK_PATH_MAX 192U
+
+enum clks_ramdisk_entry_type {
+    CLKS_RAMDISK_ENTRY_FILE = 1,
+    CLKS_RAMDISK_ENTRY_DIR = 2,
+};
+
+struct clks_ramdisk_entry {
+    enum clks_ramdisk_entry_type type;
+    char path[CLKS_RAMDISK_PATH_MAX];
+    const void *data;
+    u64 size;
+};
+
+typedef clks_bool (*clks_ramdisk_iter_fn)(const struct clks_ramdisk_entry *entry, void *ctx);
+
+clks_bool clks_ramdisk_iterate(const void *image, u64 image_size, clks_ramdisk_iter_fn iter_fn, void *ctx);
+
+#endif

clks.local.bak/include/clks/scheduler.h

@@ -0,0 +1,22 @@
+#ifndef CLKS_SCHEDULER_H
+#define CLKS_SCHEDULER_H
+
+#include <clks/task.h>
+#include <clks/types.h>
+
+struct clks_scheduler_stats {
+    u32 task_count;
+    u32 current_task_id;
+    u64 total_timer_ticks;
+    u64 context_switch_count;
+};
+
+void clks_scheduler_init(void);
+clks_bool clks_scheduler_add_kernel_task(const char *name, u32 time_slice_ticks);
+clks_bool clks_scheduler_add_kernel_task_ex(const char *name, u32 time_slice_ticks, clks_task_entry_fn entry);
+void clks_scheduler_on_timer_tick(u64 tick);
+void clks_scheduler_dispatch_current(u64 tick);
+struct clks_scheduler_stats clks_scheduler_get_stats(void);
+const struct clks_task_descriptor *clks_scheduler_get_task(u32 task_id);
+
+#endif

clks.local.bak/include/clks/serial.h

@@ -0,0 +1,8 @@
+#ifndef CLKS_SERIAL_H
+#define CLKS_SERIAL_H
+
+void clks_serial_init(void);
+void clks_serial_write_char(char ch);
+void clks_serial_write(const char *text);
+
+#endif

clks.local.bak/include/clks/service.h

@@ -0,0 +1,38 @@
+#ifndef CLKS_SERVICE_H
+#define CLKS_SERVICE_H
+
+#include <clks/types.h>
+
+#define CLKS_SERVICE_NAME_MAX 24U
+
+enum clks_service_id {
+    CLKS_SERVICE_LOG = 1,
+    CLKS_SERVICE_MEM = 2,
+    CLKS_SERVICE_FS = 3,
+    CLKS_SERVICE_DRIVER = 4,
+    CLKS_SERVICE_SCHED = 5,
+    CLKS_SERVICE_KELF = 6,
+    CLKS_SERVICE_USER = 7,
+};
+
+enum clks_service_state {
+    CLKS_SERVICE_STATE_OFFLINE = 0,
+    CLKS_SERVICE_STATE_READY = 1,
+    CLKS_SERVICE_STATE_DEGRADED = 2,
+};
+
+struct clks_service_info {
+    u32 id;
+    char name[CLKS_SERVICE_NAME_MAX];
+    enum clks_service_state state;
+    u64 heartbeat_count;
+    u64 last_heartbeat_tick;
+};
+
+void clks_service_init(void);
+clks_bool clks_service_heartbeat(u32 service_id, u64 tick);
+u64 clks_service_count(void);
+u64 clks_service_ready_count(void);
+clks_bool clks_service_get(u32 service_id, struct clks_service_info *out_info);
+
+#endif

clks.local.bak/include/clks/shell.h

@@ -0,0 +1,10 @@
+#ifndef CLKS_SHELL_H
+#define CLKS_SHELL_H
+
+#include <clks/types.h>
+
+void clks_shell_init(void);
+void clks_shell_pump_input(u32 max_chars);
+void clks_shell_tick(u64 tick);
+
+#endif

clks.local.bak/include/clks/string.h

@@ -0,0 +1,12 @@
+#ifndef CLKS_STRING_H
+#define CLKS_STRING_H
+
+#include <clks/types.h>
+
+usize clks_strlen(const char *str);
+void *clks_memset(void *dst, int value, usize count);
+void *clks_memcpy(void *dst, const void *src, usize count);
+void *clks_memmove(void *dst, const void *src, usize count);
+int clks_strcmp(const char *left, const char *right);
+
+#endif

clks.local.bak/include/clks/syscall.h

@@ -0,0 +1,106 @@
+#ifndef CLKS_SYSCALL_H
+#define CLKS_SYSCALL_H
+
+#include <clks/types.h>
+
+#define CLKS_SYSCALL_LOG_WRITE 0ULL
+#define CLKS_SYSCALL_TIMER_TICKS 1ULL
+#define CLKS_SYSCALL_TASK_COUNT 2ULL
+#define CLKS_SYSCALL_CURRENT_TASK_ID 3ULL
+#define CLKS_SYSCALL_SERVICE_COUNT 4ULL
+#define CLKS_SYSCALL_SERVICE_READY_COUNT 5ULL
+#define CLKS_SYSCALL_CONTEXT_SWITCHES 6ULL
+#define CLKS_SYSCALL_KELF_COUNT 7ULL
+#define CLKS_SYSCALL_KELF_RUNS 8ULL
+#define CLKS_SYSCALL_FS_NODE_COUNT 9ULL
+#define CLKS_SYSCALL_FS_CHILD_COUNT 10ULL
+#define CLKS_SYSCALL_FS_GET_CHILD_NAME 11ULL
+#define CLKS_SYSCALL_FS_READ 12ULL
+#define CLKS_SYSCALL_EXEC_PATH 13ULL
+#define CLKS_SYSCALL_EXEC_REQUESTS 14ULL
+#define CLKS_SYSCALL_EXEC_SUCCESS 15ULL
+#define CLKS_SYSCALL_USER_SHELL_READY 16ULL
+#define CLKS_SYSCALL_USER_EXEC_REQUESTED 17ULL
+#define CLKS_SYSCALL_USER_LAUNCH_TRIES 18ULL
+#define CLKS_SYSCALL_USER_LAUNCH_OK 19ULL
+#define CLKS_SYSCALL_USER_LAUNCH_FAIL 20ULL
+#define CLKS_SYSCALL_TTY_COUNT 21ULL
+#define CLKS_SYSCALL_TTY_ACTIVE 22ULL
+#define CLKS_SYSCALL_TTY_SWITCH 23ULL
+#define CLKS_SYSCALL_TTY_WRITE 24ULL
+#define CLKS_SYSCALL_TTY_WRITE_CHAR 25ULL
+#define CLKS_SYSCALL_KBD_GET_CHAR 26ULL
+#define CLKS_SYSCALL_FS_STAT_TYPE 27ULL
+#define CLKS_SYSCALL_FS_STAT_SIZE 28ULL
+#define CLKS_SYSCALL_FS_MKDIR 29ULL
+#define CLKS_SYSCALL_FS_WRITE 30ULL
+#define CLKS_SYSCALL_FS_APPEND 31ULL
+#define CLKS_SYSCALL_FS_REMOVE 32ULL
+#define CLKS_SYSCALL_LOG_JOURNAL_COUNT 33ULL
+#define CLKS_SYSCALL_LOG_JOURNAL_READ 34ULL
+#define CLKS_SYSCALL_KBD_BUFFERED 35ULL
+#define CLKS_SYSCALL_KBD_PUSHED 36ULL
+#define CLKS_SYSCALL_KBD_POPPED 37ULL
+#define CLKS_SYSCALL_KBD_DROPPED 38ULL
+#define CLKS_SYSCALL_KBD_HOTKEY_SWITCHES 39ULL
+#define CLKS_SYSCALL_GETPID 40ULL
+#define CLKS_SYSCALL_SPAWN_PATH 41ULL
+#define CLKS_SYSCALL_WAITPID 42ULL
+#define CLKS_SYSCALL_EXIT 43ULL
+#define CLKS_SYSCALL_SLEEP_TICKS 44ULL
+#define CLKS_SYSCALL_YIELD 45ULL
+#define CLKS_SYSCALL_SHUTDOWN 46ULL
+#define CLKS_SYSCALL_RESTART 47ULL
+#define CLKS_SYSCALL_AUDIO_AVAILABLE 48ULL
+#define CLKS_SYSCALL_AUDIO_PLAY_TONE 49ULL
+#define CLKS_SYSCALL_AUDIO_STOP 50ULL
+#define CLKS_SYSCALL_EXEC_PATHV 51ULL
+#define CLKS_SYSCALL_SPAWN_PATHV 52ULL
+#define CLKS_SYSCALL_PROC_ARGC 53ULL
+#define CLKS_SYSCALL_PROC_ARGV 54ULL
+#define CLKS_SYSCALL_PROC_ENVC 55ULL
+#define CLKS_SYSCALL_PROC_ENV 56ULL
+#define CLKS_SYSCALL_PROC_LAST_SIGNAL 57ULL
+#define CLKS_SYSCALL_PROC_FAULT_VECTOR 58ULL
+#define CLKS_SYSCALL_PROC_FAULT_ERROR 59ULL
+#define CLKS_SYSCALL_PROC_FAULT_RIP 60ULL
+#define CLKS_SYSCALL_PROC_COUNT 61ULL
+#define CLKS_SYSCALL_PROC_PID_AT 62ULL
+#define CLKS_SYSCALL_PROC_SNAPSHOT 63ULL
+#define CLKS_SYSCALL_PROC_KILL 64ULL
+#define CLKS_SYSCALL_KDBG_SYM 65ULL
+#define CLKS_SYSCALL_KDBG_BT 66ULL
+#define CLKS_SYSCALL_KDBG_REGS 67ULL
+#define CLKS_SYSCALL_STATS_TOTAL 68ULL
+#define CLKS_SYSCALL_STATS_ID_COUNT 69ULL
+#define CLKS_SYSCALL_STATS_RECENT_WINDOW 70ULL
+#define CLKS_SYSCALL_STATS_RECENT_ID 71ULL
+#define CLKS_SYSCALL_FD_OPEN 72ULL
+#define CLKS_SYSCALL_FD_READ 73ULL
+#define CLKS_SYSCALL_FD_WRITE 74ULL
+#define CLKS_SYSCALL_FD_CLOSE 75ULL
+#define CLKS_SYSCALL_FD_DUP 76ULL
+#define CLKS_SYSCALL_DL_OPEN 77ULL
+#define CLKS_SYSCALL_DL_CLOSE 78ULL
+#define CLKS_SYSCALL_DL_SYM 79ULL
+#define CLKS_SYSCALL_EXEC_PATHV_IO 80ULL
+#define CLKS_SYSCALL_FB_INFO 81ULL
+#define CLKS_SYSCALL_FB_BLIT 82ULL
+#define CLKS_SYSCALL_FB_CLEAR 83ULL
+#define CLKS_SYSCALL_KERNEL_VERSION 84ULL
+#define CLKS_SYSCALL_DISK_PRESENT 85ULL
+#define CLKS_SYSCALL_DISK_SIZE_BYTES 86ULL
+#define CLKS_SYSCALL_DISK_SECTOR_COUNT 87ULL
+#define CLKS_SYSCALL_DISK_FORMATTED 88ULL
+#define CLKS_SYSCALL_DISK_FORMAT_FAT32 89ULL
+#define CLKS_SYSCALL_DISK_MOUNT 90ULL
+#define CLKS_SYSCALL_DISK_MOUNTED 91ULL
+#define CLKS_SYSCALL_DISK_MOUNT_PATH 92ULL
+#define CLKS_SYSCALL_DISK_READ_SECTOR 93ULL
+#define CLKS_SYSCALL_DISK_WRITE_SECTOR 94ULL
+
+void clks_syscall_init(void);
+u64 clks_syscall_dispatch(void *frame_ptr);
+u64 clks_syscall_invoke_kernel(u64 id, u64 arg0, u64 arg1, u64 arg2);
+
+#endif

clks.local.bak/include/clks/task.h

@@ -0,0 +1,25 @@
+#ifndef CLKS_TASK_H
+#define CLKS_TASK_H
+
+#include <clks/types.h>
+
+#define CLKS_TASK_NAME_MAX 32U
+
+typedef void (*clks_task_entry_fn)(u64 tick);
+
+enum clks_task_state { CLKS_TASK_UNUSED = 0, CLKS_TASK_READY = 1, CLKS_TASK_RUNNING = 2, CLKS_TASK_BLOCKED = 3 };
+
+struct clks_task_descriptor {
+    u32 id;
+    char name[CLKS_TASK_NAME_MAX];
+    enum clks_task_state state;
+    u32 time_slice_ticks;
+    u32 remaining_ticks;
+    u64 total_ticks;
+    u64 switch_count;
+    u64 run_count;
+    u64 last_run_tick;
+    clks_task_entry_fn entry;
+};
+
+#endif

clks.local.bak/include/clks/tty.h

@@ -0,0 +1,18 @@
+#ifndef CLKS_TTY_H
+#define CLKS_TTY_H
+
+#include <clks/types.h>
+
+void clks_tty_init(void);
+void clks_tty_write(const char *text);
+void clks_tty_write_n(const char *text, usize len);
+void clks_tty_write_char(char ch);
+void clks_tty_switch(u32 tty_index);
+void clks_tty_tick(u64 tick);
+void clks_tty_scrollback_page_up(void);
+void clks_tty_scrollback_page_down(void);
+u32 clks_tty_active(void);
+u32 clks_tty_count(void);
+clks_bool clks_tty_ready(void);
+
+#endif

clks.local.bak/include/clks/types.h

@@ -0,0 +1,20 @@
+#ifndef CLKS_TYPES_H
+#define CLKS_TYPES_H
+
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long long u64;
+
+typedef signed char i8;
+typedef signed short i16;
+typedef signed int i32;
+typedef signed long long i64;
+
+typedef u64 usize;
+
+typedef enum clks_bool { CLKS_FALSE = 0, CLKS_TRUE = 1 } clks_bool;
+
+#define CLKS_NULL ((void *)0)
+
+#endif

clks.local.bak/include/clks/userland.h

@@ -0,0 +1,15 @@
+#ifndef CLKS_USERLAND_H
+#define CLKS_USERLAND_H
+
+#include <clks/types.h>
+
+clks_bool clks_userland_init(void);
+void clks_userland_tick(u64 tick);
+clks_bool clks_userland_shell_ready(void);
+clks_bool clks_userland_shell_exec_requested(void);
+clks_bool clks_userland_shell_auto_exec_enabled(void);
+u64 clks_userland_launch_attempts(void);
+u64 clks_userland_launch_success(void);
+u64 clks_userland_launch_failures(void);
+
+#endif

clks.local.bak/include/clks/version.h

@@ -0,0 +1,6 @@
+#ifndef CLKS_VERSION_H
+#define CLKS_VERSION_H
+
+#define CLKS_VERSION_STRING "1.0.0-alpha"
+
+#endif