style: auto-format C/C++ sources with clang-format

2026-04-21 18:44:01 +00:00 · 2026-04-18 12:28:27 +00:00
parent 14b86d50bd
commit 42159d1af8
92 changed files with 1078 additions and 1536 deletions
--- a/clks/kernel/desktop.c
+++ b/clks/kernel/desktop.c
@@ -5,21 +5,21 @@
 #include <clks/tty.h>
 #include <clks/types.h>

-#define CLKS_DESKTOP_TTY_INDEX       1U
+#define CLKS_DESKTOP_TTY_INDEX 1U

-#define CLKS_DESKTOP_BG_COLOR        0x001B2430U
-#define CLKS_DESKTOP_TOPBAR_COLOR    0x00293447U
-#define CLKS_DESKTOP_DOCK_COLOR      0x00232C3AU
-#define CLKS_DESKTOP_WINDOW_COLOR    0x00313E52U
-#define CLKS_DESKTOP_TITLE_COLOR     0x003B4A61U
-#define CLKS_DESKTOP_TEXT_FG         0x00E6EDF7U
-#define CLKS_DESKTOP_TEXT_BG         0x003B4A61U
+#define CLKS_DESKTOP_BG_COLOR 0x001B2430U
+#define CLKS_DESKTOP_TOPBAR_COLOR 0x00293447U
+#define CLKS_DESKTOP_DOCK_COLOR 0x00232C3AU
+#define CLKS_DESKTOP_WINDOW_COLOR 0x00313E52U
+#define CLKS_DESKTOP_TITLE_COLOR 0x003B4A61U
+#define CLKS_DESKTOP_TEXT_FG 0x00E6EDF7U
+#define CLKS_DESKTOP_TEXT_BG 0x003B4A61U

-#define CLKS_DESKTOP_CURSOR_FILL     0x00F5F8FFU
-#define CLKS_DESKTOP_CURSOR_OUTLINE  0x00101010U
-#define CLKS_DESKTOP_CURSOR_ACTIVE   0x00FFCE6EU
-#define CLKS_DESKTOP_CURSOR_W        16U
-#define CLKS_DESKTOP_CURSOR_H        16U
+#define CLKS_DESKTOP_CURSOR_FILL 0x00F5F8FFU
+#define CLKS_DESKTOP_CURSOR_OUTLINE 0x00101010U
+#define CLKS_DESKTOP_CURSOR_ACTIVE 0x00FFCE6EU
+#define CLKS_DESKTOP_CURSOR_W 16U
+#define CLKS_DESKTOP_CURSOR_H 16U

 struct clks_desktop_layout {
    u32 width;
@@ -207,8 +207,8 @@ static void clks_desktop_draw_static_scene(const struct clks_mouse_state *mouse)
    }

    if (clks_desktop.height > clks_desktop.topbar_h) {
-        clks_fb_fill_rect(0U, clks_desktop.topbar_h, clks_desktop.dock_w,
-                          clks_desktop.height - clks_desktop.topbar_h, CLKS_DESKTOP_DOCK_COLOR);
+        clks_fb_fill_rect(0U, clks_desktop.topbar_h, clks_desktop.dock_w, clks_desktop.height - clks_desktop.topbar_h,
+                          CLKS_DESKTOP_DOCK_COLOR);
    }

    clks_fb_fill_rect(clks_desktop.win_x, clks_desktop.win_y, clks_desktop.win_w, clks_desktop.win_h,
@@ -217,8 +217,8 @@ static void clks_desktop_draw_static_scene(const struct clks_mouse_state *mouse)
                      CLKS_DESKTOP_TITLE_COLOR);

    clks_desktop_draw_text(12U, 6U, "CLeonOS Desktop TTY2", CLKS_DESKTOP_TEXT_FG, CLKS_DESKTOP_TOPBAR_COLOR);
-    clks_desktop_draw_text(clks_desktop.win_x + 12U, clks_desktop.win_y + 6U, "Mouse Input Ready",
-                           CLKS_DESKTOP_TEXT_FG, CLKS_DESKTOP_TITLE_COLOR);
+    clks_desktop_draw_text(clks_desktop.win_x + 12U, clks_desktop.win_y + 6U, "Mouse Input Ready", CLKS_DESKTOP_TEXT_FG,
+                           CLKS_DESKTOP_TITLE_COLOR);
    clks_desktop_draw_text(clks_desktop.win_x + 16U, clks_desktop.win_y + clks_desktop.win_title_h + 16U,
                           "Stage25: Alt+F2 desktop, Alt+F1 shell", CLKS_DESKTOP_TEXT_FG, CLKS_DESKTOP_WINDOW_COLOR);

--- a/clks/kernel/driver.c
+++ b/clks/kernel/driver.c
@@ -48,10 +48,9 @@ static clks_bool clks_driver_has_elf_suffix(const char *name) {
        return CLKS_FALSE;
    }

-    return (name[len - 4U] == '.' &&
-            name[len - 3U] == 'e' &&
-            name[len - 2U] == 'l' &&
-            name[len - 1U] == 'f') ? CLKS_TRUE : CLKS_FALSE;
+    return (name[len - 4U] == '.' && name[len - 3U] == 'e' && name[len - 2U] == 'l' && name[len - 1U] == 'f')
+               ? CLKS_TRUE
+               : CLKS_FALSE;
 }

 static clks_bool clks_driver_build_path(const char *child_name, char *out_path, usize out_size) {
@@ -75,12 +74,8 @@ static clks_bool clks_driver_build_path(const char *child_name, char *out_path,
    return CLKS_TRUE;
 }

-static clks_bool clks_driver_push(const char *name,
-                                  enum clks_driver_kind kind,
-                                  enum clks_driver_state state,
-                                  clks_bool from_elf,
-                                  u64 image_size,
-                                  u64 elf_entry) {
+static clks_bool clks_driver_push(const char *name, enum clks_driver_kind kind, enum clks_driver_state state,
+                                  clks_bool from_elf, u64 image_size, u64 elf_entry) {
    struct clks_driver_info *slot;

    if (clks_driver_table_count >= CLKS_DRIVER_MAX) {
@@ -110,10 +105,12 @@ static void clks_driver_register_builtins(void) {
    clks_driver_push("serial", CLKS_DRIVER_KIND_BUILTIN_CHAR, CLKS_DRIVER_STATE_READY, CLKS_FALSE, 0ULL, 0ULL);

    if (clks_fb_ready() == CLKS_TRUE) {
-        clks_driver_push("framebuffer", CLKS_DRIVER_KIND_BUILTIN_VIDEO, CLKS_DRIVER_STATE_READY, CLKS_FALSE, 0ULL, 0ULL);
+        clks_driver_push("framebuffer", CLKS_DRIVER_KIND_BUILTIN_VIDEO, CLKS_DRIVER_STATE_READY, CLKS_FALSE, 0ULL,
+                         0ULL);
        clks_driver_push("tty", CLKS_DRIVER_KIND_BUILTIN_TTY, CLKS_DRIVER_STATE_READY, CLKS_FALSE, 0ULL, 0ULL);
    } else {
-        clks_driver_push("framebuffer", CLKS_DRIVER_KIND_BUILTIN_VIDEO, CLKS_DRIVER_STATE_FAILED, CLKS_FALSE, 0ULL, 0ULL);
+        clks_driver_push("framebuffer", CLKS_DRIVER_KIND_BUILTIN_VIDEO, CLKS_DRIVER_STATE_FAILED, CLKS_FALSE, 0ULL,
+                         0ULL);
        clks_driver_push("tty", CLKS_DRIVER_KIND_BUILTIN_TTY, CLKS_DRIVER_STATE_FAILED, CLKS_FALSE, 0ULL, 0ULL);
    }

--- a/clks/kernel/elf64.c
+++ b/clks/kernel/elf64.c
@@ -10,10 +10,10 @@

 #define CLKS_ELF64_CLASS_64 2U
 #define CLKS_ELF64_DATA_LSB 1U
-#define CLKS_ELF64_VERSION  1U
+#define CLKS_ELF64_VERSION 1U

 #define CLKS_ELF64_ET_EXEC 2U
-#define CLKS_ELF64_ET_DYN  3U
+#define CLKS_ELF64_ET_DYN 3U

 #define CLKS_ELF64_EM_X86_64 62U

@@ -46,10 +46,8 @@ struct clks_elf64_phdr {
 };

 static clks_bool clks_elf64_header_ok(const struct clks_elf64_ehdr *eh) {
-    if (eh->e_ident[0] != CLKS_ELF64_MAGIC_0 ||
-        eh->e_ident[1] != CLKS_ELF64_MAGIC_1 ||
-        eh->e_ident[2] != CLKS_ELF64_MAGIC_2 ||
-        eh->e_ident[3] != CLKS_ELF64_MAGIC_3) {
+    if (eh->e_ident[0] != CLKS_ELF64_MAGIC_0 || eh->e_ident[1] != CLKS_ELF64_MAGIC_1 ||
+        eh->e_ident[2] != CLKS_ELF64_MAGIC_2 || eh->e_ident[3] != CLKS_ELF64_MAGIC_3) {
        return CLKS_FALSE;
    }

--- a/clks/kernel/exec.c
+++ b/clks/kernel/exec.c
@@ -14,28 +14,28 @@
 typedef u64 (*clks_exec_entry_fn)(void);

 #define CLKS_EXEC_RUN_STACK_BYTES (64ULL * 1024ULL)
-#define CLKS_EXEC_MAX_PROCS       64U
-#define CLKS_EXEC_MAX_DEPTH       16U
-#define CLKS_EXEC_PATH_MAX        192U
-#define CLKS_EXEC_ARG_LINE_MAX    256U
-#define CLKS_EXEC_ENV_LINE_MAX    512U
-#define CLKS_EXEC_FD_MAX           32U
-#define CLKS_EXEC_MAX_ARGS         24U
-#define CLKS_EXEC_MAX_ENVS         24U
-#define CLKS_EXEC_ITEM_MAX        128U
+#define CLKS_EXEC_MAX_PROCS 64U
+#define CLKS_EXEC_MAX_DEPTH 16U
+#define CLKS_EXEC_PATH_MAX 192U
+#define CLKS_EXEC_ARG_LINE_MAX 256U
+#define CLKS_EXEC_ENV_LINE_MAX 512U
+#define CLKS_EXEC_FD_MAX 32U
+#define CLKS_EXEC_MAX_ARGS 24U
+#define CLKS_EXEC_MAX_ENVS 24U
+#define CLKS_EXEC_ITEM_MAX 128U
 #define CLKS_EXEC_STATUS_SIGNAL_FLAG (1ULL << 63)
 #define CLKS_EXEC_DEFAULT_KILL_SIGNAL CLKS_EXEC_SIGNAL_TERM
 #define CLKS_EXEC_KERNEL_ADDR_BASE 0xFFFF800000000000ULL
 #define CLKS_EXEC_UNWIND_CTX_BYTES 56ULL
 #define CLKS_EXEC_FD_ACCESS_MASK 0x3ULL
-#define CLKS_EXEC_O_RDONLY       0x0000ULL
-#define CLKS_EXEC_O_WRONLY       0x0001ULL
-#define CLKS_EXEC_O_RDWR         0x0002ULL
-#define CLKS_EXEC_O_CREAT        0x0040ULL
-#define CLKS_EXEC_O_TRUNC        0x0200ULL
-#define CLKS_EXEC_O_APPEND       0x0400ULL
-#define CLKS_EXEC_FD_INHERIT     ((u64)-1)
-#define CLKS_EXEC_DYNLIB_MAX       32U
+#define CLKS_EXEC_O_RDONLY 0x0000ULL
+#define CLKS_EXEC_O_WRONLY 0x0001ULL
+#define CLKS_EXEC_O_RDWR 0x0002ULL
+#define CLKS_EXEC_O_CREAT 0x0040ULL
+#define CLKS_EXEC_O_TRUNC 0x0200ULL
+#define CLKS_EXEC_O_APPEND 0x0400ULL
+#define CLKS_EXEC_FD_INHERIT ((u64) - 1)
+#define CLKS_EXEC_DYNLIB_MAX 32U

 #ifndef CLKS_CFG_EXEC_SERIAL_LOG
 #define CLKS_CFG_EXEC_SERIAL_LOG 1
@@ -53,7 +53,7 @@ typedef u64 (*clks_exec_entry_fn)(void);
 #define CLKS_EXEC_ELF64_SHT_DYNSYM 11U
 #define CLKS_EXEC_ELF64_SHN_UNDEF 0U
 #define CLKS_EXEC_ELF64_STT_NOTYPE 0U
-#define CLKS_EXEC_ELF64_STT_FUNC   2U
+#define CLKS_EXEC_ELF64_STT_FUNC 2U

 enum clks_exec_fd_kind {
    CLKS_EXEC_FD_KIND_NONE = 0,
@@ -446,8 +446,7 @@ static void clks_exec_dynlib_release_owner(u64 owner_pid) {
    }

    for (i = 0U; i < CLKS_EXEC_DYNLIB_MAX; i++) {
-        if (clks_exec_dynlib_table[i].used == CLKS_TRUE &&
-            clks_exec_dynlib_table[i].owner_pid == owner_pid) {
+        if (clks_exec_dynlib_table[i].used == CLKS_TRUE && clks_exec_dynlib_table[i].owner_pid == owner_pid) {
            clks_exec_dynlib_slot_reset(&clks_exec_dynlib_table[i]);
        }
    }
@@ -458,10 +457,8 @@ static clks_bool clks_exec_dynlib_elf_header_ok(const struct clks_exec_elf64_ehd
        return CLKS_FALSE;
    }

-    if (eh->e_ident[0] != CLKS_EXEC_ELF64_MAGIC_0 ||
-        eh->e_ident[1] != CLKS_EXEC_ELF64_MAGIC_1 ||
-        eh->e_ident[2] != CLKS_EXEC_ELF64_MAGIC_2 ||
-        eh->e_ident[3] != CLKS_EXEC_ELF64_MAGIC_3) {
+    if (eh->e_ident[0] != CLKS_EXEC_ELF64_MAGIC_0 || eh->e_ident[1] != CLKS_EXEC_ELF64_MAGIC_1 ||
+        eh->e_ident[2] != CLKS_EXEC_ELF64_MAGIC_2 || eh->e_ident[3] != CLKS_EXEC_ELF64_MAGIC_3) {
        return CLKS_FALSE;
    }

@@ -480,9 +477,7 @@ static clks_bool clks_exec_dynlib_elf_header_ok(const struct clks_exec_elf64_ehd
    return CLKS_TRUE;
 }

-static clks_bool clks_exec_dynlib_symbol_name_ptr(const char *strtab,
-                                                  u64 strtab_size,
-                                                  u32 st_name,
+static clks_bool clks_exec_dynlib_symbol_name_ptr(const char *strtab, u64 strtab_size, u32 st_name,
                                                  const char **out_name) {
    u64 i;

@@ -504,8 +499,7 @@ static clks_bool clks_exec_dynlib_symbol_name_ptr(const char *strtab,
    return CLKS_FALSE;
 }

-static clks_bool clks_exec_dynlib_resolve_symbol(const struct clks_exec_dynlib_slot *slot,
-                                                 const char *symbol,
+static clks_bool clks_exec_dynlib_resolve_symbol(const struct clks_exec_dynlib_slot *slot, const char *symbol,
                                                 u64 *out_addr) {
    const struct clks_exec_elf64_ehdr *eh;
    const struct clks_exec_elf64_shdr *shdrs;
@@ -619,9 +613,7 @@ static void clks_exec_clear_items(char items[][CLKS_EXEC_ITEM_MAX], u32 max_coun
    }
 }

-static u32 clks_exec_parse_whitespace_items(const char *line,
-                                            char items[][CLKS_EXEC_ITEM_MAX],
-                                            u32 max_count) {
+static u32 clks_exec_parse_whitespace_items(const char *line, char items[][CLKS_EXEC_ITEM_MAX], u32 max_count) {
    u32 count = 0U;
    usize i = 0U;

@@ -644,11 +636,7 @@ static u32 clks_exec_parse_whitespace_items(const char *line,
            break;
        }

-        while (line[i] != '\0' &&
-               line[i] != ' ' &&
-               line[i] != '\t' &&
-               line[i] != '\r' &&
-               line[i] != '\n') {
+        while (line[i] != '\0' && line[i] != ' ' && line[i] != '\t' && line[i] != '\r' && line[i] != '\n') {
            if (p + 1U < CLKS_EXEC_ITEM_MAX) {
                items[count][p++] = line[i];
            }
@@ -663,9 +651,7 @@ static u32 clks_exec_parse_whitespace_items(const char *line,
    return count;
 }

-static u32 clks_exec_parse_env_items(const char *line,
-                                     char items[][CLKS_EXEC_ITEM_MAX],
-                                     u32 max_count) {
+static u32 clks_exec_parse_env_items(const char *line, char items[][CLKS_EXEC_ITEM_MAX], u32 max_count) {
    u32 count = 0U;
    usize i = 0U;

@@ -713,30 +699,28 @@ static u32 clks_exec_parse_env_items(const char *line,

 static u64 clks_exec_signal_from_vector(u64 vector) {
    switch (vector) {
-        case 0ULL:
-        case 16ULL:
-        case 19ULL:
-            return 8ULL;
-        case 6ULL:
-            return 4ULL;
-        case 3ULL:
-            return 5ULL;
-        case 14ULL:
-        case 13ULL:
-        case 12ULL:
-        case 11ULL:
-        case 10ULL:
-        case 17ULL:
-            return 11ULL;
-        default:
-            return 6ULL;
+    case 0ULL:
+    case 16ULL:
+    case 19ULL:
+        return 8ULL;
+    case 6ULL:
+        return 4ULL;
+    case 3ULL:
+        return 5ULL;
+    case 14ULL:
+    case 13ULL:
+    case 12ULL:
+    case 11ULL:
+    case 10ULL:
+    case 17ULL:
+        return 11ULL;
+    default:
+        return 6ULL;
    }
 }

 static u64 clks_exec_encode_signal_status(u64 signal, u64 vector, u64 error_code) {
-    return CLKS_EXEC_STATUS_SIGNAL_FLAG |
-           (signal & 0xFFULL) |
-           ((vector & 0xFFULL) << 8) |
+    return CLKS_EXEC_STATUS_SIGNAL_FLAG | (signal & 0xFFULL) | ((vector & 0xFFULL) << 8) |
           ((error_code & 0xFFFFULL) << 16);
 }

@@ -802,7 +786,7 @@ static u64 clks_exec_alloc_pid(void) {
 static clks_bool clks_exec_fd_access_mode_valid(u64 flags) {
    u64 mode = flags & CLKS_EXEC_FD_ACCESS_MASK;
    return (mode == CLKS_EXEC_O_RDONLY || mode == CLKS_EXEC_O_WRONLY || mode == CLKS_EXEC_O_RDWR) ? CLKS_TRUE
-                                                                                                    : CLKS_FALSE;
+                                                                                                  : CLKS_FALSE;
 }

 static clks_bool clks_exec_fd_can_read(u64 flags) {
@@ -877,11 +861,8 @@ static void clks_exec_fd_init_defaults(struct clks_exec_proc_record *proc) {
 }

 static clks_bool clks_exec_fd_copy_from_parent(struct clks_exec_proc_record *child,
-                                                const struct clks_exec_proc_record *parent,
-                                                u64 parent_fd,
-                                                u64 child_fd,
-                                                clks_bool require_read,
-                                                clks_bool require_write) {
+                                               const struct clks_exec_proc_record *parent, u64 parent_fd, u64 child_fd,
+                                               clks_bool require_read, clks_bool require_write) {
    const struct clks_exec_fd_entry *src;

    if (child == CLKS_NULL || parent == CLKS_NULL || parent_fd >= CLKS_EXEC_FD_MAX || child_fd >= CLKS_EXEC_FD_MAX) {
@@ -907,10 +888,8 @@ static clks_bool clks_exec_fd_copy_from_parent(struct clks_exec_proc_record *chi
 }

 static clks_bool clks_exec_fd_apply_stdio_overrides(struct clks_exec_proc_record *child,
-                                                    const struct clks_exec_proc_record *parent,
-                                                    u64 stdin_fd,
-                                                    u64 stdout_fd,
-                                                    u64 stderr_fd) {
+                                                    const struct clks_exec_proc_record *parent, u64 stdin_fd,
+                                                    u64 stdout_fd, u64 stderr_fd) {
    if (child == CLKS_NULL) {
        return CLKS_FALSE;
    }
@@ -1069,12 +1048,9 @@ static u64 clks_exec_fd_file_write(struct clks_exec_fd_entry *entry, const void
    return size;
 }

-static struct clks_exec_proc_record *clks_exec_prepare_proc_record(i32 slot,
-                                                                    u64 pid,
-                                                                    const char *path,
-                                                                    const char *argv_line,
-                                                                    const char *env_line,
-                                                                    enum clks_exec_proc_state state) {
+static struct clks_exec_proc_record *clks_exec_prepare_proc_record(i32 slot, u64 pid, const char *path,
+                                                                   const char *argv_line, const char *env_line,
+                                                                   enum clks_exec_proc_state state) {
    struct clks_exec_proc_record *proc;

    if (slot < 0 || path == CLKS_NULL) {
@@ -1114,8 +1090,7 @@ static struct clks_exec_proc_record *clks_exec_prepare_proc_record(i32 slot,
    }

    if (proc->argv_line[0] != '\0' && proc->argc < CLKS_EXEC_MAX_ARGS) {
-        proc->argc += clks_exec_parse_whitespace_items(proc->argv_line,
-                                                       &proc->argv_items[proc->argc],
+        proc->argc += clks_exec_parse_whitespace_items(proc->argv_line, &proc->argv_items[proc->argc],
                                                       (u32)(CLKS_EXEC_MAX_ARGS - proc->argc));
    }

@@ -1421,8 +1396,7 @@ static clks_bool clks_exec_dispatch_pending_once(void) {
    }

    for (i = 0U; i < CLKS_EXEC_MAX_PROCS; i++) {
-        if (clks_exec_proc_table[i].used == CLKS_TRUE &&
-            clks_exec_proc_table[i].state == CLKS_EXEC_PROC_PENDING) {
+        if (clks_exec_proc_table[i].used == CLKS_TRUE && clks_exec_proc_table[i].state == CLKS_EXEC_PROC_PENDING) {
            u64 ignored_status = (u64)-1;

            clks_exec_pending_dispatch_active = CLKS_TRUE;
@@ -1435,13 +1409,8 @@ static clks_bool clks_exec_dispatch_pending_once(void) {
    return CLKS_FALSE;
 }

-static clks_bool clks_exec_run_path_internal(const char *path,
-                                             const char *argv_line,
-                                             const char *env_line,
-                                             u64 stdin_fd,
-                                             u64 stdout_fd,
-                                             u64 stderr_fd,
-                                             u64 *out_status,
+static clks_bool clks_exec_run_path_internal(const char *path, const char *argv_line, const char *env_line,
+                                             u64 stdin_fd, u64 stdout_fd, u64 stderr_fd, u64 *out_status,
                                             u64 *out_pid) {
    i32 slot;
    u64 pid;
@@ -1522,35 +1491,19 @@ void clks_exec_init(void) {
 }

 clks_bool clks_exec_run_path(const char *path, u64 *out_status) {
-    return clks_exec_run_path_internal(path,
-                                       CLKS_NULL,
-                                       CLKS_NULL,
-                                       CLKS_EXEC_FD_INHERIT,
-                                       CLKS_EXEC_FD_INHERIT,
-                                       CLKS_EXEC_FD_INHERIT,
-                                       out_status,
-                                       CLKS_NULL);
+    return clks_exec_run_path_internal(path, CLKS_NULL, CLKS_NULL, CLKS_EXEC_FD_INHERIT, CLKS_EXEC_FD_INHERIT,
+                                       CLKS_EXEC_FD_INHERIT, out_status, CLKS_NULL);
 }

 clks_bool clks_exec_run_pathv(const char *path, const char *argv_line, const char *env_line, u64 *out_status) {
-    return clks_exec_run_path_internal(path,
-                                       argv_line,
-                                       env_line,
-                                       CLKS_EXEC_FD_INHERIT,
-                                       CLKS_EXEC_FD_INHERIT,
-                                       CLKS_EXEC_FD_INHERIT,
-                                       out_status,
-                                       CLKS_NULL);
+    return clks_exec_run_path_internal(path, argv_line, env_line, CLKS_EXEC_FD_INHERIT, CLKS_EXEC_FD_INHERIT,
+                                       CLKS_EXEC_FD_INHERIT, out_status, CLKS_NULL);
 }

-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) {
-    return clks_exec_run_path_internal(path, argv_line, env_line, stdin_fd, stdout_fd, stderr_fd, out_status, CLKS_NULL);
+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) {
+    return clks_exec_run_path_internal(path, argv_line, env_line, stdin_fd, stdout_fd, stderr_fd, out_status,
+                                       CLKS_NULL);
 }

 clks_bool clks_exec_spawn_pathv(const char *path, const char *argv_line, const char *env_line, u64 *out_pid) {
@@ -1622,8 +1575,7 @@ u64 clks_exec_wait_pid(u64 pid, u64 *out_status) {
        clks_exec_pending_dispatch_active = CLKS_FALSE;
    }

-    if (proc->state == CLKS_EXEC_PROC_PENDING ||
-        proc->state == CLKS_EXEC_PROC_RUNNING ||
+    if (proc->state == CLKS_EXEC_PROC_PENDING || proc->state == CLKS_EXEC_PROC_RUNNING ||
        proc->state == CLKS_EXEC_PROC_STOPPED) {
        return 0ULL;
    }
@@ -1695,8 +1647,7 @@ u64 clks_exec_fd_open(const char *path, u64 flags, u64 mode) {
        return (u64)fd_slot;
    }

-    if (clks_exec_path_is_dev_null(path) == CLKS_TRUE ||
-        clks_exec_path_is_dev_zero(path) == CLKS_TRUE ||
+    if (clks_exec_path_is_dev_null(path) == CLKS_TRUE || clks_exec_path_is_dev_zero(path) == CLKS_TRUE ||
        clks_exec_path_is_dev_random(path) == CLKS_TRUE) {
        struct clks_exec_fd_entry *entry = &proc->fds[(u32)fd_slot];

@@ -1849,8 +1800,7 @@ u64 clks_exec_fd_write(u64 fd, const void *buffer, u64 size) {
        return size;
    }

-    if (entry->kind == CLKS_EXEC_FD_KIND_DEV_NULL ||
-        entry->kind == CLKS_EXEC_FD_KIND_DEV_ZERO ||
+    if (entry->kind == CLKS_EXEC_FD_KIND_DEV_NULL || entry->kind == CLKS_EXEC_FD_KIND_DEV_ZERO ||
        entry->kind == CLKS_EXEC_FD_KIND_DEV_RANDOM) {
        entry->offset += size;
        return size;
@@ -2159,9 +2109,7 @@ static u64 clks_exec_proc_runtime_ticks(const struct clks_exec_proc_record *proc

    runtime = proc->runtime_ticks_accum;

-    if (proc->state == CLKS_EXEC_PROC_RUNNING &&
-        proc->run_started_tick != 0ULL &&
-        now_tick > proc->run_started_tick) {
+    if (proc->state == CLKS_EXEC_PROC_RUNNING && proc->run_started_tick != 0ULL && now_tick > proc->run_started_tick) {
        runtime += (now_tick - proc->run_started_tick);
    }

@@ -2374,9 +2322,7 @@ u64 clks_exec_force_stop_tty_running_process(u32 tty_index, u64 *out_pid) {
        if (slot >= 0) {
            const struct clks_exec_proc_record *proc = &clks_exec_proc_table[(u32)slot];

-            if (proc->used == CLKS_TRUE &&
-                proc->state == CLKS_EXEC_PROC_RUNNING &&
-                proc->tty_index == tty_index &&
+            if (proc->used == CLKS_TRUE && proc->state == CLKS_EXEC_PROC_RUNNING && proc->tty_index == tty_index &&
                clks_exec_path_is_user_program(proc->path) == CLKS_TRUE) {
                u64 ret = clks_exec_proc_kill(current_pid, CLKS_EXEC_SIGNAL_STOP);

@@ -2392,8 +2338,7 @@ u64 clks_exec_force_stop_tty_running_process(u32 tty_index, u64 *out_pid) {
    for (i = 0U; i < CLKS_EXEC_MAX_PROCS; i++) {
        u64 ret;

-        if (clks_exec_proc_table[i].used != CLKS_TRUE ||
-            clks_exec_proc_table[i].state != CLKS_EXEC_PROC_RUNNING ||
+        if (clks_exec_proc_table[i].used != CLKS_TRUE || clks_exec_proc_table[i].state != CLKS_EXEC_PROC_RUNNING ||
            clks_exec_proc_table[i].tty_index != tty_index ||
            clks_exec_path_is_user_program(clks_exec_proc_table[i].path) == CLKS_FALSE) {
            continue;
@@ -2413,10 +2358,7 @@ u64 clks_exec_force_stop_tty_running_process(u32 tty_index, u64 *out_pid) {
    return 0ULL;
 }

-clks_bool clks_exec_try_unwind_signaled_process(u64 interrupted_rip,
-                                                u64 *io_rip,
-                                                u64 *io_rdi,
-                                                u64 *io_rsi) {
+clks_bool clks_exec_try_unwind_signaled_process(u64 interrupted_rip, u64 *io_rip, u64 *io_rdi, u64 *io_rsi) {
    i32 depth_index;

    if (io_rip == CLKS_NULL || io_rdi == CLKS_NULL || io_rsi == CLKS_NULL) {
@@ -2456,12 +2398,7 @@ clks_bool clks_exec_try_unwind_signaled_process(u64 interrupted_rip,
 #endif
 }

-clks_bool clks_exec_handle_exception(u64 vector,
-                                     u64 error_code,
-                                     u64 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) {
    i32 depth_index;
    struct clks_exec_proc_record *proc;
    u64 signal;
@@ -2589,4 +2526,3 @@ clks_bool clks_exec_current_path_is_user(void) {
    proc = &clks_exec_proc_table[(u32)slot];
    return clks_exec_path_is_user_program(proc->path);
 }
-
--- a/clks/kernel/fs.c
+++ b/clks/kernel/fs.c
@@ -7,7 +7,7 @@
 #include <clks/types.h>

 #define CLKS_FS_MAX_NODES 512U
-#define CLKS_FS_PATH_MAX  CLKS_RAMDISK_PATH_MAX
+#define CLKS_FS_PATH_MAX CLKS_RAMDISK_PATH_MAX

 #define CLKS_FS_NODE_FLAG_HEAP_DATA 0x0001U

@@ -103,10 +103,7 @@ static clks_bool clks_fs_internal_in_temp_tree(const char *internal_path) {
        return CLKS_FALSE;
    }

-    if (internal_path[0] != 't' ||
-        internal_path[1] != 'e' ||
-        internal_path[2] != 'm' ||
-        internal_path[3] != 'p') {
+    if (internal_path[0] != 't' || internal_path[1] != 'e' || internal_path[2] != 'm' || internal_path[3] != 'p') {
        return CLKS_FALSE;
    }

@@ -248,11 +245,8 @@ static i32 clks_fs_alloc_slot(void) {
    return (i32)(clks_fs_nodes_used - 1U);
 }

-static i32 clks_fs_create_or_update_node(const char *internal_path,
-                                         enum clks_fs_node_type type,
-                                         u16 parent,
-                                         const void *data,
-                                         u64 size) {
+static i32 clks_fs_create_or_update_node(const char *internal_path, enum clks_fs_node_type type, u16 parent,
+                                         const void *data, u64 size) {
    i32 existing;
    i32 slot;
    usize path_len;
@@ -433,11 +427,8 @@ static clks_bool clks_fs_ramdisk_visit(const struct clks_ramdisk_entry *entry, v
            return CLKS_FALSE;
        }

-        if (clks_fs_create_or_update_node(entry->path,
-                                          CLKS_FS_NODE_FILE,
-                                          (u16)parent_index,
-                                          entry->data,
-                                          entry->size) < 0) {
+        if (clks_fs_create_or_update_node(entry->path, CLKS_FS_NODE_FILE, (u16)parent_index, entry->data, entry->size) <
+            0) {
            return CLKS_FALSE;
        }

@@ -448,9 +439,7 @@ static clks_bool clks_fs_ramdisk_visit(const struct clks_ramdisk_entry *entry, v
    return CLKS_TRUE;
 }

-static clks_bool clks_fs_build_file_payload(const void *data,
-                                            u64 size,
-                                            const void **out_data,
+static clks_bool clks_fs_build_file_payload(const void *data, u64 size, const void **out_data,
                                            clks_bool *out_heap_owned) {
    void *payload;

@@ -764,13 +753,7 @@ clks_bool clks_fs_write_all(const char *path, const void *data, u64 size) {
        clks_fs_node_release_heap_data((u16)node_index);
    }

-    node_index = clks_fs_create_or_update_node(
-        internal,
-        CLKS_FS_NODE_FILE,
-        (u16)parent_index,
-        payload_data,
-        size
-    );
+    node_index = clks_fs_create_or_update_node(internal, CLKS_FS_NODE_FILE, (u16)parent_index, payload_data, size);

    if (node_index < 0) {
        if (payload_heap_owned == CLKS_TRUE) {
--- a/clks/kernel/heap.c
+++ b/clks/kernel/heap.c
@@ -3,8 +3,8 @@
 #include <clks/types.h>

 #define CLKS_HEAP_ARENA_SIZE (1024ULL * 1024ULL)
-#define CLKS_HEAP_ALIGN      16ULL
-#define CLKS_HEAP_MAGIC      0x434C454F4E4F534FULL
+#define CLKS_HEAP_ALIGN 16ULL
+#define CLKS_HEAP_MAGIC 0x434C454F4E4F534FULL

 struct clks_heap_block {
    usize size;
--- a/clks/kernel/interrupts.c
+++ b/clks/kernel/interrupts.c
@@ -11,23 +11,23 @@
 #include <clks/types.h>

 #define CLKS_IDT_ENTRY_COUNT 256U
-#define CLKS_INTERRUPT_GATE  0x8EU
-#define CLKS_USER_INT_GATE   0xEEU
+#define CLKS_INTERRUPT_GATE 0x8EU
+#define CLKS_USER_INT_GATE 0xEEU

-#define CLKS_PIC1_CMD   0x20U
-#define CLKS_PIC1_DATA  0x21U
-#define CLKS_PIC2_CMD   0xA0U
-#define CLKS_PIC2_DATA  0xA1U
-#define CLKS_PIC_EOI    0x20U
+#define CLKS_PIC1_CMD 0x20U
+#define CLKS_PIC1_DATA 0x21U
+#define CLKS_PIC2_CMD 0xA0U
+#define CLKS_PIC2_DATA 0xA1U
+#define CLKS_PIC_EOI 0x20U

-#define CLKS_IRQ_BASE   32U
-#define CLKS_IRQ_TIMER  32U
+#define CLKS_IRQ_BASE 32U
+#define CLKS_IRQ_TIMER 32U
 #define CLKS_IRQ_KEYBOARD 33U
-#define CLKS_IRQ_MOUSE  44U
-#define CLKS_IRQ_LAST   47U
+#define CLKS_IRQ_MOUSE 44U
+#define CLKS_IRQ_LAST 47U
 #define CLKS_SYSCALL_VECTOR 128U

-#define CLKS_PS2_DATA_PORT  0x60U
+#define CLKS_PS2_DATA_PORT 0x60U
 #define CLKS_PS2_STATUS_PORT 0x64U

 struct clks_idt_entry {
@@ -125,40 +125,38 @@ static struct clks_idt_entry clks_idt[CLKS_IDT_ENTRY_COUNT];
 static u16 clks_idt_code_selector = 0x08U;
 static u64 clks_timer_ticks = 0;

-static const char *clks_exception_names[32] = {
-    "DE DIVIDE ERROR",
-    "DB DEBUG",
-    "NMI",
-    "BP BREAKPOINT",
-    "OF OVERFLOW",
-    "BR BOUND RANGE",
-    "UD INVALID OPCODE",
-    "NM DEVICE NOT AVAILABLE",
-    "DF DOUBLE FAULT",
-    "COPROCESSOR SEGMENT",
-    "TS INVALID TSS",
-    "NP SEGMENT NOT PRESENT",
-    "SS STACK SEGMENT",
-    "GP GENERAL PROTECTION",
-    "PF PAGE FAULT",
-    "RESERVED",
-    "MF X87 FLOAT",
-    "AC ALIGNMENT CHECK",
-    "MC MACHINE CHECK",
-    "XF SIMD FLOAT",
-    "VE VIRT EXCEPTION",
-    "CP CONTROL PROTECTION",
-    "RESERVED",
-    "RESERVED",
-    "RESERVED",
-    "RESERVED",
-    "RESERVED",
-    "RESERVED",
-    "HV HYPERVISOR",
-    "VC VMM COMM",
-    "SX SECURITY",
-    "RESERVED"
-};
+static const char *clks_exception_names[32] = {"DE DIVIDE ERROR",
+                                               "DB DEBUG",
+                                               "NMI",
+                                               "BP BREAKPOINT",
+                                               "OF OVERFLOW",
+                                               "BR BOUND RANGE",
+                                               "UD INVALID OPCODE",
+                                               "NM DEVICE NOT AVAILABLE",
+                                               "DF DOUBLE FAULT",
+                                               "COPROCESSOR SEGMENT",
+                                               "TS INVALID TSS",
+                                               "NP SEGMENT NOT PRESENT",
+                                               "SS STACK SEGMENT",
+                                               "GP GENERAL PROTECTION",
+                                               "PF PAGE FAULT",
+                                               "RESERVED",
+                                               "MF X87 FLOAT",
+                                               "AC ALIGNMENT CHECK",
+                                               "MC MACHINE CHECK",
+                                               "XF SIMD FLOAT",
+                                               "VE VIRT EXCEPTION",
+                                               "CP CONTROL PROTECTION",
+                                               "RESERVED",
+                                               "RESERVED",
+                                               "RESERVED",
+                                               "RESERVED",
+                                               "RESERVED",
+                                               "RESERVED",
+                                               "HV HYPERVISOR",
+                                               "VC VMM COMM",
+                                               "SX SECURITY",
+                                               "RESERVED"};

 static inline void clks_outb(u16 port, u8 value) {
    __asm__ volatile("outb %0, %1" : : "a"(value), "Nd"(port));
@@ -234,7 +232,6 @@ static void clks_load_idt(void) {
    __asm__ volatile("lidt %0" : : "m"(idtr));
 }

-
 static clks_bool clks_ps2_has_output(void) {
    return (clks_inb(CLKS_PS2_STATUS_PORT) & 0x01U) != 0U ? CLKS_TRUE : CLKS_FALSE;
 }
@@ -251,20 +248,12 @@ void clks_interrupt_dispatch(struct clks_interrupt_frame *frame) {
    }

    if (vector < 32U) {
-        if (clks_exec_handle_exception(vector,
-                                       frame->error_code,
-                                       frame->rip,
-                                       &frame->rip,
-                                       &frame->rdi,
-                                       &frame->rsi) == CLKS_TRUE) {
+        if (clks_exec_handle_exception(vector, frame->error_code, frame->rip, &frame->rip, &frame->rdi, &frame->rsi) ==
+            CLKS_TRUE) {
            return;
        }

-        clks_panic_exception(clks_exception_names[vector],
-                             vector,
-                             frame->error_code,
-                             frame->rip,
-                             frame->rbp,
+        clks_panic_exception(clks_exception_names[vector], vector, frame->error_code, frame->rip, frame->rbp,
                             frame->rsp);
    }

--- a/clks/kernel/kelf.c
+++ b/clks/kernel/kelf.c
@@ -69,10 +69,7 @@ static void clks_kelf_copy_name(char *dst, usize dst_size, const char *src) {
    dst[i] = '\0';
 }

-static clks_bool clks_kelf_load_runtime_image(const void *image,
-                                              u64 size,
-                                              void **out_runtime,
-                                              u64 *out_runtime_size,
+static clks_bool clks_kelf_load_runtime_image(const void *image, u64 size, void **out_runtime, u64 *out_runtime_size,
                                              clks_kelf_entry_fn *out_entry) {
    const struct clks_elf64_ehdr *eh;
    u64 min_vaddr = 0xffffffffffffffffULL;
@@ -143,9 +140,7 @@ static clks_bool clks_kelf_load_runtime_image(const void *image,
            continue;
        }

-        clks_memcpy(runtime + (usize)(ph->p_vaddr - min_vaddr),
-                    (const u8 *)image + ph->p_offset,
-                    (usize)ph->p_filesz);
+        clks_memcpy(runtime + (usize)(ph->p_vaddr - min_vaddr), (const u8 *)image + ph->p_offset, (usize)ph->p_filesz);
    }

    if (eh->e_entry < min_vaddr || eh->e_entry >= max_vaddr) {
@@ -253,4 +248,3 @@ u64 clks_kelf_count(void) {
 u64 clks_kelf_total_runs(void) {
    return clks_kelf_total_runs_count;
 }
-
--- a/clks/kernel/keyboard.c
+++ b/clks/kernel/keyboard.c
@@ -5,30 +5,30 @@
 #include <clks/tty.h>
 #include <clks/types.h>

-#define CLKS_SC_ALT              0x38U
-#define CLKS_SC_LSHIFT           0x2AU
-#define CLKS_SC_RSHIFT           0x36U
-#define CLKS_SC_CTRL             0x1DU
-#define CLKS_SC_F1               0x3BU
-#define CLKS_SC_F2               0x3CU
-#define CLKS_SC_F3               0x3DU
-#define CLKS_SC_F4               0x3EU
-#define CLKS_SC_C                0x2EU
-#define CLKS_SC_EXT_PREFIX       0xE0U
+#define CLKS_SC_ALT 0x38U
+#define CLKS_SC_LSHIFT 0x2AU
+#define CLKS_SC_RSHIFT 0x36U
+#define CLKS_SC_CTRL 0x1DU
+#define CLKS_SC_F1 0x3BU
+#define CLKS_SC_F2 0x3CU
+#define CLKS_SC_F3 0x3DU
+#define CLKS_SC_F4 0x3EU
+#define CLKS_SC_C 0x2EU
+#define CLKS_SC_EXT_PREFIX 0xE0U

-#define CLKS_SC_EXT_HOME         0x47U
-#define CLKS_SC_EXT_UP           0x48U
-#define CLKS_SC_EXT_LEFT         0x4BU
-#define CLKS_SC_EXT_RIGHT        0x4DU
-#define CLKS_SC_EXT_END          0x4FU
-#define CLKS_SC_EXT_DOWN         0x50U
-#define CLKS_SC_EXT_PAGEUP       0x49U
-#define CLKS_SC_EXT_PAGEDOWN     0x51U
-#define CLKS_SC_EXT_DELETE       0x53U
+#define CLKS_SC_EXT_HOME 0x47U
+#define CLKS_SC_EXT_UP 0x48U
+#define CLKS_SC_EXT_LEFT 0x4BU
+#define CLKS_SC_EXT_RIGHT 0x4DU
+#define CLKS_SC_EXT_END 0x4FU
+#define CLKS_SC_EXT_DOWN 0x50U
+#define CLKS_SC_EXT_PAGEUP 0x49U
+#define CLKS_SC_EXT_PAGEDOWN 0x51U
+#define CLKS_SC_EXT_DELETE 0x53U

-#define CLKS_KBD_INPUT_CAP       256U
-#define CLKS_KBD_TTY_MAX         8U
-#define CLKS_KBD_DROP_LOG_EVERY  64ULL
+#define CLKS_KBD_INPUT_CAP 256U
+#define CLKS_KBD_TTY_MAX 8U
+#define CLKS_KBD_DROP_LOG_EVERY 64ULL

 #ifndef CLKS_CFG_KBD_TTY_SWITCH_HOTKEY
 #define CLKS_CFG_KBD_TTY_SWITCH_HOTKEY 1
@@ -43,26 +43,20 @@
 #endif

 static const char clks_kbd_map[128] = {
-    [2] = '1', [3] = '2', [4] = '3', [5] = '4', [6] = '5', [7] = '6', [8] = '7', [9] = '8',
-    [10] = '9', [11] = '0', [12] = '-', [13] = '=', [14] = '\b', [15] = '\t',
-    [16] = 'q', [17] = 'w', [18] = 'e', [19] = 'r', [20] = 't', [21] = 'y', [22] = 'u', [23] = 'i',
-    [24] = 'o', [25] = 'p', [26] = '[', [27] = ']', [28] = '\n',
-    [30] = 'a', [31] = 's', [32] = 'd', [33] = 'f', [34] = 'g', [35] = 'h', [36] = 'j', [37] = 'k',
-    [38] = 'l', [39] = ';', [40] = '\'', [41] = '`', [43] = '\\',
-    [44] = 'z', [45] = 'x', [46] = 'c', [47] = 'v', [48] = 'b', [49] = 'n', [50] = 'm',
-    [51] = ',', [52] = '.', [53] = '/', [57] = ' '
-};
+    [2] = '1',  [3] = '2',   [4] = '3',  [5] = '4',   [6] = '5',   [7] = '6',  [8] = '7',  [9] = '8',  [10] = '9',
+    [11] = '0', [12] = '-',  [13] = '=', [14] = '\b', [15] = '\t', [16] = 'q', [17] = 'w', [18] = 'e', [19] = 'r',
+    [20] = 't', [21] = 'y',  [22] = 'u', [23] = 'i',  [24] = 'o',  [25] = 'p', [26] = '[', [27] = ']', [28] = '\n',
+    [30] = 'a', [31] = 's',  [32] = 'd', [33] = 'f',  [34] = 'g',  [35] = 'h', [36] = 'j', [37] = 'k', [38] = 'l',
+    [39] = ';', [40] = '\'', [41] = '`', [43] = '\\', [44] = 'z',  [45] = 'x', [46] = 'c', [47] = 'v', [48] = 'b',
+    [49] = 'n', [50] = 'm',  [51] = ',', [52] = '.',  [53] = '/',  [57] = ' '};

 static const char clks_kbd_shift_map[128] = {
-    [2] = '!', [3] = '@', [4] = '#', [5] = '$', [6] = '%', [7] = '^', [8] = '&', [9] = '*',
-    [10] = '(', [11] = ')', [12] = '_', [13] = '+', [14] = '\b', [15] = '\t',
-    [16] = 'Q', [17] = 'W', [18] = 'E', [19] = 'R', [20] = 'T', [21] = 'Y', [22] = 'U', [23] = 'I',
-    [24] = 'O', [25] = 'P', [26] = '{', [27] = '}', [28] = '\n',
-    [30] = 'A', [31] = 'S', [32] = 'D', [33] = 'F', [34] = 'G', [35] = 'H', [36] = 'J', [37] = 'K',
-    [38] = 'L', [39] = ':', [40] = '"', [41] = '~', [43] = '|',
-    [44] = 'Z', [45] = 'X', [46] = 'C', [47] = 'V', [48] = 'B', [49] = 'N', [50] = 'M',
-    [51] = '<', [52] = '>', [53] = '?', [57] = ' '
-};
+    [2] = '!',  [3] = '@',  [4] = '#',  [5] = '$',   [6] = '%',   [7] = '^',  [8] = '&',  [9] = '*',  [10] = '(',
+    [11] = ')', [12] = '_', [13] = '+', [14] = '\b', [15] = '\t', [16] = 'Q', [17] = 'W', [18] = 'E', [19] = 'R',
+    [20] = 'T', [21] = 'Y', [22] = 'U', [23] = 'I',  [24] = 'O',  [25] = 'P', [26] = '{', [27] = '}', [28] = '\n',
+    [30] = 'A', [31] = 'S', [32] = 'D', [33] = 'F',  [34] = 'G',  [35] = 'H', [36] = 'J', [37] = 'K', [38] = 'L',
+    [39] = ':', [40] = '"', [41] = '~', [43] = '|',  [44] = 'Z',  [45] = 'X', [46] = 'C', [47] = 'V', [48] = 'B',
+    [49] = 'N', [50] = 'M', [51] = '<', [52] = '>',  [53] = '?',  [57] = ' '};

 static char clks_kbd_input_queue[CLKS_KBD_TTY_MAX][CLKS_KBD_INPUT_CAP];
 static u16 clks_kbd_input_head[CLKS_KBD_TTY_MAX];
@@ -114,22 +108,22 @@ static char clks_keyboard_translate_ext_scancode(u8 code) {
    clks_bool shift_active = clks_keyboard_shift_active();

    switch (code) {
-        case CLKS_SC_EXT_LEFT:
-            return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_LEFT : CLKS_KEY_LEFT;
-        case CLKS_SC_EXT_RIGHT:
-            return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_RIGHT : CLKS_KEY_RIGHT;
-        case CLKS_SC_EXT_UP:
-            return CLKS_KEY_UP;
-        case CLKS_SC_EXT_DOWN:
-            return CLKS_KEY_DOWN;
-        case CLKS_SC_EXT_HOME:
-            return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_HOME : CLKS_KEY_HOME;
-        case CLKS_SC_EXT_END:
-            return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_END : CLKS_KEY_END;
-        case CLKS_SC_EXT_DELETE:
-            return CLKS_KEY_DELETE;
-        default:
-            return '\0';
+    case CLKS_SC_EXT_LEFT:
+        return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_LEFT : CLKS_KEY_LEFT;
+    case CLKS_SC_EXT_RIGHT:
+        return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_RIGHT : CLKS_KEY_RIGHT;
+    case CLKS_SC_EXT_UP:
+        return CLKS_KEY_UP;
+    case CLKS_SC_EXT_DOWN:
+        return CLKS_KEY_DOWN;
+    case CLKS_SC_EXT_HOME:
+        return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_HOME : CLKS_KEY_HOME;
+    case CLKS_SC_EXT_END:
+        return (shift_active == CLKS_TRUE) ? CLKS_KEY_SHIFT_END : CLKS_KEY_END;
+    case CLKS_SC_EXT_DELETE:
+        return CLKS_KEY_DELETE;
+    default:
+        return '\0';
    }
 }

@@ -172,9 +166,8 @@ static clks_bool clks_keyboard_should_pump_shell_now(void) {
 }

 static char clks_keyboard_translate_scancode(u8 code) {
-    clks_bool shift_active = (clks_kbd_lshift_down == CLKS_TRUE || clks_kbd_rshift_down == CLKS_TRUE)
-                                 ? CLKS_TRUE
-                                 : CLKS_FALSE;
+    clks_bool shift_active =
+        (clks_kbd_lshift_down == CLKS_TRUE || clks_kbd_rshift_down == CLKS_TRUE) ? CLKS_TRUE : CLKS_FALSE;

    if (shift_active == CLKS_TRUE) {
        return clks_kbd_shift_map[code];
@@ -199,17 +192,17 @@ static clks_bool clks_keyboard_try_emit_ctrl_shortcut(u8 code, u32 tty_index) {
    }

    switch (code) {
-        case 0x1EU:
-            shortcut = CLKS_KEY_SELECT_ALL;
-            break;
-        case 0x2EU:
-            shortcut = CLKS_KEY_COPY;
-            break;
-        case 0x2FU:
-            shortcut = CLKS_KEY_PASTE;
-            break;
-        default:
-            return CLKS_FALSE;
+    case 0x1EU:
+        shortcut = CLKS_KEY_SELECT_ALL;
+        break;
+    case 0x2EU:
+        shortcut = CLKS_KEY_COPY;
+        break;
+    case 0x2FU:
+        shortcut = CLKS_KEY_PASTE;
+        break;
+    default:
+        return CLKS_FALSE;
    }

    if (clks_keyboard_queue_push_for_tty(tty_index, shortcut) == CLKS_TRUE &&
@@ -383,9 +376,7 @@ void clks_keyboard_handle_scancode(u8 scancode) {
        return;
    }

-    if (CLKS_CFG_KBD_TTY_SWITCH_HOTKEY != 0 &&
-        clks_kbd_alt_down == CLKS_TRUE &&
-        code >= CLKS_SC_F1 &&
+    if (CLKS_CFG_KBD_TTY_SWITCH_HOTKEY != 0 && clks_kbd_alt_down == CLKS_TRUE && code >= CLKS_SC_F1 &&
        code <= CLKS_SC_F4) {
        u32 target = (u32)(code - CLKS_SC_F1);
        u32 before = clks_tty_active();
@@ -471,4 +462,3 @@ u64 clks_keyboard_push_count(void) {
 u64 clks_keyboard_pop_count(void) {
    return clks_kbd_pop_count;
 }
-
--- a/clks/kernel/kmain.c
+++ b/clks/kernel/kmain.c
@@ -142,18 +142,18 @@ static void clks_task_kworker(u64 tick) {
    clks_service_heartbeat(CLKS_SERVICE_SCHED, tick);

    switch (phase) {
-        case 0U:
-            clks_service_heartbeat(CLKS_SERVICE_MEM, tick);
-            break;
-        case 1U:
-            clks_service_heartbeat(CLKS_SERVICE_FS, tick);
-            break;
-        case 2U:
-            clks_service_heartbeat(CLKS_SERVICE_DRIVER, tick);
-            break;
-        default:
-            clks_service_heartbeat(CLKS_SERVICE_LOG, tick);
-            break;
+    case 0U:
+        clks_service_heartbeat(CLKS_SERVICE_MEM, tick);
+        break;
+    case 1U:
+        clks_service_heartbeat(CLKS_SERVICE_FS, tick);
+        break;
+    case 2U:
+        clks_service_heartbeat(CLKS_SERVICE_DRIVER, tick);
+        break;
+    default:
+        clks_service_heartbeat(CLKS_SERVICE_LOG, tick);
+        break;
    }

    phase = (phase + 1U) & 3U;
--- a/clks/kernel/limine_requests.c
+++ b/clks/kernel/limine_requests.c
@@ -1,42 +1,42 @@
 #include <clks/boot.h>
 #include <clks/compiler.h>

-CLKS_USED static volatile u64 limine_requests_start[]
-    __attribute__((section(".limine_requests_start"))) = LIMINE_REQUESTS_START_MARKER;
+CLKS_USED static volatile u64 limine_requests_start[] __attribute__((section(".limine_requests_start"))) =
+    LIMINE_REQUESTS_START_MARKER;

-CLKS_USED static volatile u64 limine_base_revision[]
-    __attribute__((section(".limine_requests"))) = LIMINE_BASE_REVISION(3);
+CLKS_USED static volatile u64 limine_base_revision[] __attribute__((section(".limine_requests"))) =
+    LIMINE_BASE_REVISION(3);

 CLKS_USED static volatile struct limine_framebuffer_request limine_framebuffer_request
    __attribute__((section(".limine_requests"))) = {
        .id = LIMINE_FRAMEBUFFER_REQUEST,
        .revision = 0,
        .response = CLKS_NULL,
-    };
+};

 CLKS_USED static volatile struct limine_memmap_request limine_memmap_request
    __attribute__((section(".limine_requests"))) = {
        .id = LIMINE_MEMMAP_REQUEST,
        .revision = 0,
        .response = CLKS_NULL,
-    };
+};

 CLKS_USED static volatile struct limine_executable_file_request limine_executable_file_request
    __attribute__((section(".limine_requests"))) = {
        .id = LIMINE_EXECUTABLE_FILE_REQUEST,
        .revision = 0,
        .response = CLKS_NULL,
-    };
+};

 CLKS_USED static volatile struct limine_module_request limine_module_request
    __attribute__((section(".limine_requests"))) = {
        .id = LIMINE_MODULE_REQUEST,
        .revision = 0,
        .response = CLKS_NULL,
-    };
+};

-CLKS_USED static volatile u64 limine_requests_end[]
-    __attribute__((section(".limine_requests_end"))) = LIMINE_REQUESTS_END_MARKER;
+CLKS_USED static volatile u64 limine_requests_end[] __attribute__((section(".limine_requests_end"))) =
+    LIMINE_REQUESTS_END_MARKER;

 clks_bool clks_boot_base_revision_supported(void) {
    return (limine_base_revision[2] == 0) ? CLKS_TRUE : CLKS_FALSE;
--- a/clks/kernel/log.c
+++ b/clks/kernel/log.c
@@ -14,16 +14,16 @@ static u32 clks_log_journal_count_live = 0U;

 static const char *clks_log_level_name(enum clks_log_level level) {
    switch (level) {
-        case CLKS_LOG_DEBUG:
-            return "DEBUG";
-        case CLKS_LOG_INFO:
-            return "INFO";
-        case CLKS_LOG_WARN:
-            return "WARN";
-        case CLKS_LOG_ERROR:
-            return "ERROR";
-        default:
-            return "UNK";
+    case CLKS_LOG_DEBUG:
+        return "DEBUG";
+    case CLKS_LOG_INFO:
+        return "INFO";
+    case CLKS_LOG_WARN:
+        return "WARN";
+    case CLKS_LOG_ERROR:
+        return "ERROR";
+    default:
+        return "UNK";
    }
 }

@@ -91,29 +91,23 @@ static void clks_log_journal_push(const char *line) {

 static const char *clks_log_level_ansi(enum clks_log_level level) {
    switch (level) {
-        case CLKS_LOG_DEBUG:
-            return "\x1B[38;5;110m";
-        case CLKS_LOG_INFO:
-            return "\x1B[38;5;120m";
-        case CLKS_LOG_WARN:
-            return "\x1B[1;38;5;220m";
-        case CLKS_LOG_ERROR:
-            return "\x1B[1;38;5;203m";
-        default:
-            return "\x1B[38;5;250m";
+    case CLKS_LOG_DEBUG:
+        return "\x1B[38;5;110m";
+    case CLKS_LOG_INFO:
+        return "\x1B[38;5;120m";
+    case CLKS_LOG_WARN:
+        return "\x1B[1;38;5;220m";
+    case CLKS_LOG_ERROR:
+        return "\x1B[1;38;5;203m";
+    default:
+        return "\x1B[38;5;250m";
    }
 }

 static const char *clks_log_tag_ansi(const char *tag) {
    static const char *palette[] = {
-        "\x1B[38;5;81m",
-        "\x1B[38;5;117m",
-        "\x1B[38;5;159m",
-        "\x1B[38;5;45m",
-        "\x1B[38;5;75m",
-        "\x1B[38;5;141m",
-        "\x1B[38;5;214m",
-        "\x1B[38;5;168m",
+        "\x1B[38;5;81m", "\x1B[38;5;117m", "\x1B[38;5;159m", "\x1B[38;5;45m",
+        "\x1B[38;5;75m", "\x1B[38;5;141m", "\x1B[38;5;214m", "\x1B[38;5;168m",
    };
    u32 hash = 5381U;
    usize i = 0U;
--- a/clks/kernel/mouse.c
+++ b/clks/kernel/mouse.c
@@ -3,26 +3,26 @@
 #include <clks/mouse.h>
 #include <clks/types.h>

-#define CLKS_PS2_DATA_PORT      0x60U
-#define CLKS_PS2_STATUS_PORT    0x64U
-#define CLKS_PS2_CMD_PORT       0x64U
-#define CLKS_PS2_STATUS_OBF     0x01U
-#define CLKS_PS2_STATUS_IBF     0x02U
+#define CLKS_PS2_DATA_PORT 0x60U
+#define CLKS_PS2_STATUS_PORT 0x64U
+#define CLKS_PS2_CMD_PORT 0x64U
+#define CLKS_PS2_STATUS_OBF 0x01U
+#define CLKS_PS2_STATUS_IBF 0x02U

 #define CLKS_PS2_CMD_ENABLE_AUX 0xA8U
-#define CLKS_PS2_CMD_READ_CFG   0x20U
-#define CLKS_PS2_CMD_WRITE_CFG  0x60U
-#define CLKS_PS2_CMD_WRITE_AUX  0xD4U
+#define CLKS_PS2_CMD_READ_CFG 0x20U
+#define CLKS_PS2_CMD_WRITE_CFG 0x60U
+#define CLKS_PS2_CMD_WRITE_AUX 0xD4U

 #define CLKS_PS2_MOUSE_CMD_RESET_DEFAULTS 0xF6U
-#define CLKS_PS2_MOUSE_CMD_ENABLE_STREAM  0xF4U
-#define CLKS_PS2_MOUSE_ACK                0xFAU
+#define CLKS_PS2_MOUSE_CMD_ENABLE_STREAM 0xF4U
+#define CLKS_PS2_MOUSE_ACK 0xFAU

-#define CLKS_MOUSE_IO_TIMEOUT      100000U
-#define CLKS_MOUSE_DRAIN_MAX       64U
-#define CLKS_MOUSE_SYNC_BIT        0x08U
-#define CLKS_MOUSE_OVERFLOW_MASK   0xC0U
-#define CLKS_MOUSE_BUTTON_MASK     0x07U
+#define CLKS_MOUSE_IO_TIMEOUT 100000U
+#define CLKS_MOUSE_DRAIN_MAX 64U
+#define CLKS_MOUSE_SYNC_BIT 0x08U
+#define CLKS_MOUSE_OVERFLOW_MASK 0xC0U
+#define CLKS_MOUSE_BUTTON_MASK 0x07U

 struct clks_mouse_runtime {
    i32 x;
@@ -193,8 +193,7 @@ void clks_mouse_init(void) {
        return;
    }

-    if (clks_mouse_write_cmd(CLKS_PS2_CMD_READ_CFG) == CLKS_FALSE ||
-        clks_mouse_read_data(&config) == CLKS_FALSE) {
+    if (clks_mouse_write_cmd(CLKS_PS2_CMD_READ_CFG) == CLKS_FALSE || clks_mouse_read_data(&config) == CLKS_FALSE) {
        clks_log(CLKS_LOG_WARN, "MOUSE", "PS2 READ CFG FAILED");
        return;
    }
@@ -202,8 +201,7 @@ void clks_mouse_init(void) {
    config |= 0x02U;
    config &= (u8)~0x20U;

-    if (clks_mouse_write_cmd(CLKS_PS2_CMD_WRITE_CFG) == CLKS_FALSE ||
-        clks_mouse_write_data(config) == CLKS_FALSE) {
+    if (clks_mouse_write_cmd(CLKS_PS2_CMD_WRITE_CFG) == CLKS_FALSE || clks_mouse_write_data(config) == CLKS_FALSE) {
        clks_log(CLKS_LOG_WARN, "MOUSE", "PS2 WRITE CFG FAILED");
        return;
    }
@@ -214,8 +212,7 @@ void clks_mouse_init(void) {
        return;
    }

-    if (clks_mouse_send_device_cmd(CLKS_PS2_MOUSE_CMD_ENABLE_STREAM, &ack) == CLKS_FALSE ||
-        ack != CLKS_PS2_MOUSE_ACK) {
+    if (clks_mouse_send_device_cmd(CLKS_PS2_MOUSE_CMD_ENABLE_STREAM, &ack) == CLKS_FALSE || ack != CLKS_PS2_MOUSE_ACK) {
        clks_log(CLKS_LOG_WARN, "MOUSE", "PS2 ENABLE STREAM FAILED");
        return;
    }
--- a/clks/kernel/panic.c
+++ b/clks/kernel/panic.c
@@ -9,10 +9,10 @@
 #define CLKS_PANIC_BG 0x00200000U
 #define CLKS_PANIC_FG 0x00FFE0E0U

-#define CLKS_PANIC_BACKTRACE_MAX        20U
-#define CLKS_PANIC_STACK_WINDOW_BYTES   (128ULL * 1024ULL)
-#define CLKS_PANIC_SYMBOL_FILE          "/system/kernel.sym"
-#define CLKS_PANIC_KERNEL_ADDR_BASE     0xFFFF800000000000ULL
+#define CLKS_PANIC_BACKTRACE_MAX 20U
+#define CLKS_PANIC_STACK_WINDOW_BYTES (128ULL * 1024ULL)
+#define CLKS_PANIC_SYMBOL_FILE "/system/kernel.sym"
+#define CLKS_PANIC_KERNEL_ADDR_BASE 0xFFFF800000000000ULL

 struct clks_panic_console {
    u32 cols;
@@ -225,13 +225,8 @@ static u8 clks_panic_hex_value(char ch) {
    return (u8)(10 + (ch - 'A'));
 }

-static clks_bool clks_panic_parse_symbol_line(const char *line,
-                                              usize len,
-                                              u64 *out_addr,
-                                              const char **out_name,
-                                              usize *out_name_len,
-                                              const char **out_source,
-                                              usize *out_source_len) {
+static clks_bool clks_panic_parse_symbol_line(const char *line, usize len, u64 *out_addr, const char **out_name,
+                                              usize *out_name_len, const char **out_source, usize *out_source_len) {
    usize i = 0U;
    u64 addr = 0ULL;
    u32 digits = 0U;
@@ -328,12 +323,8 @@ static clks_bool clks_panic_symbols_ready(void) {
    return CLKS_TRUE;
 }

-static clks_bool clks_panic_lookup_symbol(u64 addr,
-                                          const char **out_name,
-                                          usize *out_name_len,
-                                          u64 *out_base,
-                                          const char **out_source,
-                                          usize *out_source_len) {
+static clks_bool clks_panic_lookup_symbol(u64 addr, const char **out_name, usize *out_name_len, u64 *out_base,
+                                          const char **out_source, usize *out_source_len) {
    const char *data;
    const char *end;
    const char *line;
@@ -381,12 +372,7 @@ static clks_bool clks_panic_lookup_symbol(u64 addr,
            data++;
        }

-        if (clks_panic_parse_symbol_line(line,
-                                         line_len,
-                                         &line_addr,
-                                         &line_name,
-                                         &line_name_len,
-                                         &line_source,
+        if (clks_panic_parse_symbol_line(line, line_len, &line_addr, &line_name, &line_name_len, &line_source,
                                         &line_source_len) == CLKS_FALSE) {
            continue;
        }
@@ -632,12 +618,7 @@ CLKS_NORETURN void clks_panic(const char *reason) {
    clks_panic_halt_loop();
 }

-CLKS_NORETURN void clks_panic_exception(const char *name,
-                                        u64 vector,
-                                        u64 error_code,
-                                        u64 rip,
-                                        u64 rbp,
-                                        u64 rsp) {
+CLKS_NORETURN void clks_panic_exception(const char *name, u64 vector, u64 error_code, u64 rip, u64 rbp, u64 rsp) {
    struct clks_panic_console console;
    char hex_buf[19];

--- a/clks/kernel/pmm.c
+++ b/clks/kernel/pmm.c
@@ -3,7 +3,7 @@
 #include <clks/types.h>

 #define CLKS_PMM_MAX_TRACKED_PAGES 262144ULL
-#define CLKS_PMM_MIN_USABLE_ADDR   0x100000ULL
+#define CLKS_PMM_MIN_USABLE_ADDR 0x100000ULL

 static u64 clks_pmm_free_stack[CLKS_PMM_MAX_TRACKED_PAGES];
 static u64 clks_pmm_free_top = 0;
--- a/clks/kernel/service.c
+++ b/clks/kernel/service.c
@@ -70,24 +70,18 @@ void clks_service_init(void) {
    heap_stats = clks_heap_get_stats();

    clks_service_register(CLKS_SERVICE_LOG, "log", CLKS_SERVICE_STATE_READY);
-    clks_service_register(CLKS_SERVICE_MEM,
-                          "memory",
+    clks_service_register(CLKS_SERVICE_MEM, "memory",
                          (heap_stats.total_bytes > 0U) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
-    clks_service_register(CLKS_SERVICE_FS,
-                          "filesystem",
+    clks_service_register(CLKS_SERVICE_FS, "filesystem",
                          (clks_fs_is_ready() == CLKS_TRUE) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
-    clks_service_register(CLKS_SERVICE_DRIVER,
-                          "driver",
+    clks_service_register(CLKS_SERVICE_DRIVER, "driver",
                          (clks_driver_count() > 0ULL) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
-    clks_service_register(CLKS_SERVICE_SCHED,
-                          "scheduler",
-                          CLKS_SERVICE_STATE_READY);
-    clks_service_register(CLKS_SERVICE_KELF,
-                          "kelf",
+    clks_service_register(CLKS_SERVICE_SCHED, "scheduler", CLKS_SERVICE_STATE_READY);
+    clks_service_register(CLKS_SERVICE_KELF, "kelf",
                          (clks_kelf_count() > 0ULL) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
-    clks_service_register(CLKS_SERVICE_USER,
-                          "userland",
-                          (clks_userland_shell_ready() == CLKS_TRUE) ? CLKS_SERVICE_STATE_READY : CLKS_SERVICE_STATE_DEGRADED);
+    clks_service_register(CLKS_SERVICE_USER, "userland",
+                          (clks_userland_shell_ready() == CLKS_TRUE) ? CLKS_SERVICE_STATE_READY
+                                                                     : CLKS_SERVICE_STATE_DEGRADED);

    clks_log(CLKS_LOG_INFO, "SRV", "KERNEL SERVICES ONLINE");
    clks_log_hex(CLKS_LOG_INFO, "SRV", "COUNT", clks_service_count());
--- a/clks/kernel/shell.c
+++ b/clks/kernel/shell.c
@@ -12,17 +12,17 @@
 #include <clks/tty.h>
 #include <clks/types.h>

-#define CLKS_SHELL_LINE_MAX       192U
-#define CLKS_SHELL_CMD_MAX         32U
-#define CLKS_SHELL_ARG_MAX        160U
-#define CLKS_SHELL_NAME_MAX        96U
-#define CLKS_SHELL_PATH_MAX       192U
-#define CLKS_SHELL_CAT_LIMIT      512U
-#define CLKS_SHELL_DMESG_LINE_MAX  256U
-#define CLKS_SHELL_DMESG_DEFAULT    64ULL
-#define CLKS_SHELL_INPUT_BUDGET   128U
-#define CLKS_SHELL_CLEAR_LINES     56U
-#define CLKS_SHELL_HISTORY_MAX     16U
+#define CLKS_SHELL_LINE_MAX 192U
+#define CLKS_SHELL_CMD_MAX 32U
+#define CLKS_SHELL_ARG_MAX 160U
+#define CLKS_SHELL_NAME_MAX 96U
+#define CLKS_SHELL_PATH_MAX 192U
+#define CLKS_SHELL_CAT_LIMIT 512U
+#define CLKS_SHELL_DMESG_LINE_MAX 256U
+#define CLKS_SHELL_DMESG_DEFAULT 64ULL
+#define CLKS_SHELL_INPUT_BUDGET 128U
+#define CLKS_SHELL_CLEAR_LINES 56U
+#define CLKS_SHELL_HISTORY_MAX 16U
 #define CLKS_SHELL_PROMPT_TEXT "cleonos> "

 static clks_bool clks_shell_ready = CLKS_FALSE;
@@ -173,35 +173,24 @@ static void clks_shell_history_push(const char *line) {
        return;
    }

-    if (clks_shell_history_count > 0U &&
-        clks_strcmp(clks_shell_history[clks_shell_history_count - 1U], line) == 0) {
+    if (clks_shell_history_count > 0U && clks_strcmp(clks_shell_history[clks_shell_history_count - 1U], line) == 0) {
        clks_shell_history_cancel_nav();
        return;
    }

    if (clks_shell_history_count < CLKS_SHELL_HISTORY_MAX) {
-        clks_shell_copy_line(
-            clks_shell_history[clks_shell_history_count],
-            sizeof(clks_shell_history[clks_shell_history_count]),
-            line
-        );
+        clks_shell_copy_line(clks_shell_history[clks_shell_history_count],
+                             sizeof(clks_shell_history[clks_shell_history_count]), line);
        clks_shell_history_count++;
    } else {
        u32 i;

        for (i = 1U; i < CLKS_SHELL_HISTORY_MAX; i++) {
-            clks_memcpy(
-                clks_shell_history[i - 1U],
-                clks_shell_history[i],
-                CLKS_SHELL_LINE_MAX
-            );
+            clks_memcpy(clks_shell_history[i - 1U], clks_shell_history[i], CLKS_SHELL_LINE_MAX);
        }

-        clks_shell_copy_line(
-            clks_shell_history[CLKS_SHELL_HISTORY_MAX - 1U],
-            sizeof(clks_shell_history[CLKS_SHELL_HISTORY_MAX - 1U]),
-            line
-        );
+        clks_shell_copy_line(clks_shell_history[CLKS_SHELL_HISTORY_MAX - 1U],
+                             sizeof(clks_shell_history[CLKS_SHELL_HISTORY_MAX - 1U]), line);
    }

    clks_shell_history_cancel_nav();
@@ -287,10 +276,7 @@ static void clks_shell_trim(char *line) {
    }
 }

-static void clks_shell_split_line(const char *line,
-                                  char *out_cmd,
-                                  usize out_cmd_size,
-                                  char *out_arg,
+static void clks_shell_split_line(const char *line, char *out_cmd, usize out_cmd_size, char *out_arg,
                                  usize out_arg_size) {
    usize i = 0U;
    usize cmd_pos = 0U;
@@ -407,7 +393,8 @@ static clks_bool clks_shell_resolve_exec_path(const char *arg, char *out_path, u
    return CLKS_TRUE;
 }

-static clks_bool clks_shell_path_push_component(char *path, usize path_size, usize *io_len, const char *component, usize comp_len) {
+static clks_bool clks_shell_path_push_component(char *path, usize path_size, usize *io_len, const char *component,
+                                                usize comp_len) {
    if (path == CLKS_NULL || io_len == CLKS_NULL || component == CLKS_NULL || comp_len == 0U) {
        return CLKS_FALSE;
    }
@@ -528,9 +515,7 @@ static clks_bool clks_shell_resolve_path(const char *arg, char *out_path, usize
    return clks_shell_path_parse_into(arg, out_path, out_size, &len);
 }

-static clks_bool clks_shell_split_first_and_rest(const char *arg,
-                                                 char *out_first,
-                                                 usize out_first_size,
+static clks_bool clks_shell_split_first_and_rest(const char *arg, char *out_first, usize out_first_size,
                                                 const char **out_rest) {
    usize i = 0U;
    usize p = 0U;
@@ -567,17 +552,13 @@ static clks_bool clks_shell_split_first_and_rest(const char *arg,
    return CLKS_TRUE;
 }

-static clks_bool clks_shell_split_two_args(const char *arg,
-                                           char *out_first,
-                                           usize out_first_size,
-                                           char *out_second,
+static clks_bool clks_shell_split_two_args(const char *arg, char *out_first, usize out_first_size, char *out_second,
                                           usize out_second_size) {
    usize i = 0U;
    usize p = 0U;

-    if (arg == CLKS_NULL ||
-        out_first == CLKS_NULL || out_first_size == 0U ||
-        out_second == CLKS_NULL || out_second_size == 0U) {
+    if (arg == CLKS_NULL || out_first == CLKS_NULL || out_first_size == 0U || out_second == CLKS_NULL ||
+        out_second_size == 0U) {
        return CLKS_FALSE;
    }

@@ -1018,7 +999,8 @@ static clks_bool clks_shell_cmd_mv(const char *arg) {
        return CLKS_FALSE;
    }

-    if (clks_shell_path_is_under_temp(src_path) == CLKS_FALSE || clks_shell_path_is_under_temp(dst_path) == CLKS_FALSE) {
+    if (clks_shell_path_is_under_temp(src_path) == CLKS_FALSE ||
+        clks_shell_path_is_under_temp(dst_path) == CLKS_FALSE) {
        clks_shell_writeln("mv: source and destination must be under /temp");
        return CLKS_FALSE;
    }
@@ -1563,4 +1545,3 @@ void clks_shell_tick(u64 tick) {
    clks_shell_drain_input(CLKS_SHELL_INPUT_BUDGET);
    clks_shell_process_pending_command();
 }
-
--- a/clks/kernel/syscall.c
+++ b/clks/kernel/syscall.c
@@ -16,24 +16,24 @@
 #include <clks/types.h>
 #include <clks/userland.h>

-#define CLKS_SYSCALL_LOG_MAX_LEN      191U
-#define CLKS_SYSCALL_PATH_MAX         192U
-#define CLKS_SYSCALL_NAME_MAX          96U
-#define CLKS_SYSCALL_TTY_MAX_LEN     2048U
-#define CLKS_SYSCALL_FS_IO_CHUNK_LEN  65536U
-#define CLKS_SYSCALL_JOURNAL_MAX_LEN  256U
-#define CLKS_SYSCALL_ARG_LINE_MAX     256U
-#define CLKS_SYSCALL_ENV_LINE_MAX     512U
-#define CLKS_SYSCALL_ITEM_MAX         128U
+#define CLKS_SYSCALL_LOG_MAX_LEN 191U
+#define CLKS_SYSCALL_PATH_MAX 192U
+#define CLKS_SYSCALL_NAME_MAX 96U
+#define CLKS_SYSCALL_TTY_MAX_LEN 2048U
+#define CLKS_SYSCALL_FS_IO_CHUNK_LEN 65536U
+#define CLKS_SYSCALL_JOURNAL_MAX_LEN 256U
+#define CLKS_SYSCALL_ARG_LINE_MAX 256U
+#define CLKS_SYSCALL_ENV_LINE_MAX 512U
+#define CLKS_SYSCALL_ITEM_MAX 128U
 #define CLKS_SYSCALL_PROCFS_TEXT_MAX 2048U
 #define CLKS_SYSCALL_USER_TRACE_BUDGET 128ULL
-#define CLKS_SYSCALL_KDBG_TEXT_MAX   2048U
+#define CLKS_SYSCALL_KDBG_TEXT_MAX 2048U
 #define CLKS_SYSCALL_KDBG_BT_MAX_FRAMES 16U
 #define CLKS_SYSCALL_KDBG_STACK_WINDOW_BYTES (128ULL * 1024ULL)
 #define CLKS_SYSCALL_KERNEL_SYMBOL_FILE "/system/kernel.sym"
 #define CLKS_SYSCALL_KERNEL_ADDR_BASE 0xFFFF800000000000ULL
-#define CLKS_SYSCALL_STATS_MAX_ID     CLKS_SYSCALL_EXEC_PATHV_IO
-#define CLKS_SYSCALL_STATS_RING_SIZE  256U
+#define CLKS_SYSCALL_STATS_MAX_ID CLKS_SYSCALL_EXEC_PATHV_IO
+#define CLKS_SYSCALL_STATS_RING_SIZE 256U

 #ifndef CLKS_CFG_PROCFS
 #define CLKS_CFG_PROCFS 1
@@ -103,7 +103,6 @@ static inline void clks_syscall_outw(u16 port, u16 value) {
 }
 #endif

-
 static clks_bool clks_syscall_copy_user_string(u64 src_addr, char *dst, usize dst_size) {
    const char *src = (const char *)src_addr;
    usize i = 0U;
@@ -497,13 +496,8 @@ static u8 clks_syscall_hex_value(char ch) {
    return (u8)(10 + (ch - 'A'));
 }

-static clks_bool clks_syscall_parse_symbol_line(const char *line,
-                                                usize len,
-                                                u64 *out_addr,
-                                                const char **out_name,
-                                                usize *out_name_len,
-                                                const char **out_source,
-                                                usize *out_source_len) {
+static clks_bool clks_syscall_parse_symbol_line(const char *line, usize len, u64 *out_addr, const char **out_name,
+                                                usize *out_name_len, const char **out_source, usize *out_source_len) {
    usize i = 0U;
    u64 addr = 0ULL;
    u32 digits = 0U;
@@ -600,12 +594,8 @@ static clks_bool clks_syscall_symbols_ready(void) {
    return CLKS_TRUE;
 }

-static clks_bool clks_syscall_lookup_symbol(u64 addr,
-                                            const char **out_name,
-                                            usize *out_name_len,
-                                            u64 *out_base,
-                                            const char **out_source,
-                                            usize *out_source_len) {
+static clks_bool clks_syscall_lookup_symbol(u64 addr, const char **out_name, usize *out_name_len, u64 *out_base,
+                                            const char **out_source, usize *out_source_len) {
    const char *data;
    const char *end;
    const char *line;
@@ -653,12 +643,7 @@ static clks_bool clks_syscall_lookup_symbol(u64 addr,
            data++;
        }

-        if (clks_syscall_parse_symbol_line(line,
-                                           line_len,
-                                           &line_addr,
-                                           &line_name,
-                                           &line_name_len,
-                                           &line_source,
+        if (clks_syscall_parse_symbol_line(line, line_len, &line_addr, &line_name, &line_name_len, &line_source,
                                           &line_source_len) == CLKS_FALSE) {
            continue;
        }
@@ -904,10 +889,8 @@ static u64 clks_syscall_kdbg_bt(u64 arg0) {
                current_rbp = next_rbp;
            }
        } else {
-            pos = clks_syscall_procfs_append_text(text,
-                                                  sizeof(text),
-                                                  pos,
-                                                  "NOTE: stack walk skipped (rbp not in current kernel stack window)\n");
+            pos = clks_syscall_procfs_append_text(
+                text, sizeof(text), pos, "NOTE: stack walk skipped (rbp not in current kernel stack window)\n");
        }
    }
 #else
@@ -941,8 +924,7 @@ static clks_bool clks_syscall_procfs_snapshot_for_path(const char *path, struct
    return CLKS_FALSE;
 }

-static usize clks_syscall_procfs_render_snapshot(char *out,
-                                                 usize out_size,
+static usize clks_syscall_procfs_render_snapshot(char *out, usize out_size,
                                                 const struct clks_exec_proc_snapshot *snap) {
    usize pos = 0U;

@@ -1048,10 +1030,7 @@ static usize clks_syscall_procfs_render_list(char *out, usize out_size) {
    return pos;
 }

-static clks_bool clks_syscall_procfs_render_file(const char *path,
-                                                 char *out,
-                                                 usize out_size,
-                                                 usize *out_len) {
+static clks_bool clks_syscall_procfs_render_file(const char *path, char *out, usize out_size, usize *out_len) {
    struct clks_exec_proc_snapshot snap;

    if (out_len != CLKS_NULL) {
@@ -1093,8 +1072,7 @@ static u64 clks_syscall_fs_child_count(u64 arg0) {
        return (u64)-1;
    }

-    if (CLKS_CFG_PROCFS != 0 &&
-        clks_syscall_fs_is_root(path) == CLKS_TRUE &&
+    if (CLKS_CFG_PROCFS != 0 && clks_syscall_fs_is_root(path) == CLKS_TRUE &&
        clks_syscall_fs_has_real_proc_dir() == CLKS_FALSE) {
        return base_count + 1ULL;
    }
@@ -1148,8 +1126,7 @@ static u64 clks_syscall_fs_get_child_name(u64 arg0, u64 arg1, u64 arg2) {
        }
    }

-    if (CLKS_CFG_PROCFS != 0 &&
-        clks_syscall_fs_is_root(path) == CLKS_TRUE &&
+    if (CLKS_CFG_PROCFS != 0 && clks_syscall_fs_is_root(path) == CLKS_TRUE &&
        clks_syscall_fs_has_real_proc_dir() == CLKS_FALSE) {
        if (arg1 == 0ULL) {
            clks_memset((void *)arg2, 0, CLKS_SYSCALL_NAME_MAX);
@@ -1186,8 +1163,7 @@ static u64 clks_syscall_fs_read(u64 arg0, u64 arg1, u64 arg2) {
    }

    if (CLKS_CFG_PROCFS != 0 &&
-        (clks_syscall_procfs_is_list(path) == CLKS_TRUE ||
-         clks_syscall_procfs_is_self(path) == CLKS_TRUE ||
+        (clks_syscall_procfs_is_list(path) == CLKS_TRUE || clks_syscall_procfs_is_self(path) == CLKS_TRUE ||
         clks_syscall_procfs_parse_pid(path, &file_size) == CLKS_TRUE)) {
        char proc_text[CLKS_SYSCALL_PROCFS_TEXT_MAX];
        usize proc_len = 0U;
@@ -1282,7 +1258,8 @@ static u64 clks_syscall_exec_pathv_io(u64 arg0, u64 arg1, u64 arg2) {
        return (u64)-1;
    }

-    if (clks_exec_run_pathv_io(path, argv_line, env_line, req.stdin_fd, req.stdout_fd, req.stderr_fd, &status) == CLKS_FALSE) {
+    if (clks_exec_run_pathv_io(path, argv_line, env_line, req.stdin_fd, req.stdout_fd, req.stderr_fd, &status) ==
+        CLKS_FALSE) {
        return (u64)-1;
    }

@@ -1462,7 +1439,6 @@ static u64 clks_syscall_restart(void) {
    return 1ULL;
 }

-
 static u64 clks_syscall_audio_available(void) {
    return (clks_audio_available() == CLKS_TRUE) ? 1ULL : 0ULL;
 }
@@ -1736,9 +1712,7 @@ static u64 clks_syscall_stats_recent_id(u64 id) {

 static void clks_syscall_trace_user_program(u64 id) {
    clks_bool user_program_running =
-        (clks_exec_is_running() == CLKS_TRUE && clks_exec_current_path_is_user() == CLKS_TRUE)
-            ? CLKS_TRUE
-            : CLKS_FALSE;
+        (clks_exec_is_running() == CLKS_TRUE && clks_exec_current_path_is_user() == CLKS_TRUE) ? CLKS_TRUE : CLKS_FALSE;

    if (user_program_running == CLKS_FALSE) {
        if (clks_syscall_user_trace_active == CLKS_TRUE) {
@@ -1800,189 +1774,184 @@ u64 clks_syscall_dispatch(void *frame_ptr) {
    clks_syscall_trace_user_program(id);

    switch (id) {
-        case CLKS_SYSCALL_LOG_WRITE:
-            return clks_syscall_log_write(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_TIMER_TICKS:
-            return clks_interrupts_timer_ticks();
-        case CLKS_SYSCALL_TASK_COUNT: {
-            struct clks_scheduler_stats stats = clks_scheduler_get_stats();
-            return stats.task_count;
-        }
-        case CLKS_SYSCALL_CURRENT_TASK_ID: {
-            struct clks_scheduler_stats stats = clks_scheduler_get_stats();
-            return stats.current_task_id;
-        }
-        case CLKS_SYSCALL_SERVICE_COUNT:
-            return clks_service_count();
-        case CLKS_SYSCALL_SERVICE_READY_COUNT:
-            return clks_service_ready_count();
-        case CLKS_SYSCALL_CONTEXT_SWITCHES: {
-            struct clks_scheduler_stats stats = clks_scheduler_get_stats();
-            return stats.context_switch_count;
-        }
-        case CLKS_SYSCALL_KELF_COUNT:
-            return clks_kelf_count();
-        case CLKS_SYSCALL_KELF_RUNS:
-            return clks_kelf_total_runs();
-        case CLKS_SYSCALL_FS_NODE_COUNT:
-            return clks_fs_node_count();
-        case CLKS_SYSCALL_FS_CHILD_COUNT:
-            return clks_syscall_fs_child_count(frame->rbx);
-        case CLKS_SYSCALL_FS_GET_CHILD_NAME:
-            return clks_syscall_fs_get_child_name(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_FS_READ:
-            return clks_syscall_fs_read(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_EXEC_PATH:
-            return clks_syscall_exec_path(frame->rbx);
-        case CLKS_SYSCALL_EXEC_PATHV:
-            return clks_syscall_exec_pathv(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_EXEC_PATHV_IO:
-            return clks_syscall_exec_pathv_io(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_EXEC_REQUESTS:
-            return clks_exec_request_count();
-        case CLKS_SYSCALL_EXEC_SUCCESS:
-            return clks_exec_success_count();
-        case CLKS_SYSCALL_USER_SHELL_READY:
-            return (clks_userland_shell_ready() == CLKS_TRUE) ? 1ULL : 0ULL;
-        case CLKS_SYSCALL_USER_EXEC_REQUESTED:
-            return (clks_userland_shell_exec_requested() == CLKS_TRUE) ? 1ULL : 0ULL;
-        case CLKS_SYSCALL_USER_LAUNCH_TRIES:
-            return clks_userland_launch_attempts();
-        case CLKS_SYSCALL_USER_LAUNCH_OK:
-            return clks_userland_launch_success();
-        case CLKS_SYSCALL_USER_LAUNCH_FAIL:
-            return clks_userland_launch_failures();
-        case CLKS_SYSCALL_TTY_COUNT:
-            return (u64)clks_tty_count();
-        case CLKS_SYSCALL_TTY_ACTIVE:
-            return (u64)clks_tty_active();
-        case CLKS_SYSCALL_TTY_SWITCH:
-            clks_tty_switch((u32)frame->rbx);
-            return (u64)clks_tty_active();
-        case CLKS_SYSCALL_TTY_WRITE:
-            return clks_syscall_tty_write(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_TTY_WRITE_CHAR:
-            return clks_syscall_tty_write_char(frame->rbx);
-        case CLKS_SYSCALL_KBD_GET_CHAR:
-            return clks_syscall_kbd_get_char();
-        case CLKS_SYSCALL_FS_STAT_TYPE:
-            return clks_syscall_fs_stat_type(frame->rbx);
-        case CLKS_SYSCALL_FS_STAT_SIZE:
-            return clks_syscall_fs_stat_size(frame->rbx);
-        case CLKS_SYSCALL_FS_MKDIR:
-            return clks_syscall_fs_mkdir(frame->rbx);
-        case CLKS_SYSCALL_FS_WRITE:
-            return clks_syscall_fs_write(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_FS_APPEND:
-            return clks_syscall_fs_append(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_FS_REMOVE:
-            return clks_syscall_fs_remove(frame->rbx);
-        case CLKS_SYSCALL_LOG_JOURNAL_COUNT:
-            return clks_syscall_log_journal_count();
-        case CLKS_SYSCALL_LOG_JOURNAL_READ:
-            return clks_syscall_log_journal_read(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_KBD_BUFFERED:
-            return clks_keyboard_buffered_count();
-        case CLKS_SYSCALL_KBD_PUSHED:
-            return clks_keyboard_push_count();
-        case CLKS_SYSCALL_KBD_POPPED:
-            return clks_keyboard_pop_count();
-        case CLKS_SYSCALL_KBD_DROPPED:
-            return clks_keyboard_drop_count();
-        case CLKS_SYSCALL_KBD_HOTKEY_SWITCHES:
-            return clks_keyboard_hotkey_switch_count();
-        case CLKS_SYSCALL_GETPID:
-            return clks_syscall_getpid();
-        case CLKS_SYSCALL_SPAWN_PATH:
-            return clks_syscall_spawn_path(frame->rbx);
-        case CLKS_SYSCALL_SPAWN_PATHV:
-            return clks_syscall_spawn_pathv(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_WAITPID:
-            return clks_syscall_waitpid(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_PROC_ARGC:
-            return clks_syscall_proc_argc();
-        case CLKS_SYSCALL_PROC_ARGV:
-            return clks_syscall_proc_argv(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_PROC_ENVC:
-            return clks_syscall_proc_envc();
-        case CLKS_SYSCALL_PROC_ENV:
-            return clks_syscall_proc_env(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_PROC_LAST_SIGNAL:
-            return clks_syscall_proc_last_signal();
-        case CLKS_SYSCALL_PROC_FAULT_VECTOR:
-            return clks_syscall_proc_fault_vector();
-        case CLKS_SYSCALL_PROC_FAULT_ERROR:
-            return clks_syscall_proc_fault_error();
-        case CLKS_SYSCALL_PROC_FAULT_RIP:
-            return clks_syscall_proc_fault_rip();
-        case CLKS_SYSCALL_PROC_COUNT:
-            return clks_syscall_proc_count();
-        case CLKS_SYSCALL_PROC_PID_AT:
-            return clks_syscall_proc_pid_at(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_PROC_SNAPSHOT:
-            return clks_syscall_proc_snapshot(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_PROC_KILL:
-            return clks_syscall_proc_kill(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_EXIT:
-            return clks_syscall_exit(frame->rbx);
-        case CLKS_SYSCALL_SLEEP_TICKS:
-            return clks_syscall_sleep_ticks(frame->rbx);
-        case CLKS_SYSCALL_YIELD:
-            return clks_syscall_yield();
-        case CLKS_SYSCALL_SHUTDOWN:
-            return clks_syscall_shutdown();
-        case CLKS_SYSCALL_RESTART:
-            return clks_syscall_restart();
-        case CLKS_SYSCALL_AUDIO_AVAILABLE:
-            return clks_syscall_audio_available();
-        case CLKS_SYSCALL_AUDIO_PLAY_TONE:
-            return clks_syscall_audio_play_tone(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_AUDIO_STOP:
-            return clks_syscall_audio_stop();
-        case CLKS_SYSCALL_KDBG_SYM:
-            return clks_syscall_kdbg_sym(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_KDBG_BT:
-            return clks_syscall_kdbg_bt(frame->rbx);
-        case CLKS_SYSCALL_KDBG_REGS:
-            return clks_syscall_kdbg_regs(frame->rbx, frame->rcx);
-        case CLKS_SYSCALL_STATS_TOTAL:
-            return clks_syscall_stats_total_count();
-        case CLKS_SYSCALL_STATS_ID_COUNT:
-            return clks_syscall_stats_id(frame->rbx);
-        case CLKS_SYSCALL_STATS_RECENT_WINDOW:
-            return clks_syscall_stats_recent_window();
-        case CLKS_SYSCALL_STATS_RECENT_ID:
-            return clks_syscall_stats_recent_id(frame->rbx);
-        case CLKS_SYSCALL_FD_OPEN:
-            return clks_syscall_fd_open(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_FD_READ:
-            return clks_syscall_fd_read(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_FD_WRITE:
-            return clks_syscall_fd_write(frame->rbx, frame->rcx, frame->rdx);
-        case CLKS_SYSCALL_FD_CLOSE:
-            return clks_syscall_fd_close(frame->rbx);
-        case CLKS_SYSCALL_FD_DUP:
-            return clks_syscall_fd_dup(frame->rbx);
-        case CLKS_SYSCALL_DL_OPEN:
-            return clks_syscall_dl_open(frame->rbx);
-        case CLKS_SYSCALL_DL_CLOSE:
-            return clks_syscall_dl_close(frame->rbx);
-        case CLKS_SYSCALL_DL_SYM:
-            return clks_syscall_dl_sym(frame->rbx, frame->rcx);
-        default:
-            return (u64)-1;
+    case CLKS_SYSCALL_LOG_WRITE:
+        return clks_syscall_log_write(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_TIMER_TICKS:
+        return clks_interrupts_timer_ticks();
+    case CLKS_SYSCALL_TASK_COUNT: {
+        struct clks_scheduler_stats stats = clks_scheduler_get_stats();
+        return stats.task_count;
+    }
+    case CLKS_SYSCALL_CURRENT_TASK_ID: {
+        struct clks_scheduler_stats stats = clks_scheduler_get_stats();
+        return stats.current_task_id;
+    }
+    case CLKS_SYSCALL_SERVICE_COUNT:
+        return clks_service_count();
+    case CLKS_SYSCALL_SERVICE_READY_COUNT:
+        return clks_service_ready_count();
+    case CLKS_SYSCALL_CONTEXT_SWITCHES: {
+        struct clks_scheduler_stats stats = clks_scheduler_get_stats();
+        return stats.context_switch_count;
+    }
+    case CLKS_SYSCALL_KELF_COUNT:
+        return clks_kelf_count();
+    case CLKS_SYSCALL_KELF_RUNS:
+        return clks_kelf_total_runs();
+    case CLKS_SYSCALL_FS_NODE_COUNT:
+        return clks_fs_node_count();
+    case CLKS_SYSCALL_FS_CHILD_COUNT:
+        return clks_syscall_fs_child_count(frame->rbx);
+    case CLKS_SYSCALL_FS_GET_CHILD_NAME:
+        return clks_syscall_fs_get_child_name(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_FS_READ:
+        return clks_syscall_fs_read(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_EXEC_PATH:
+        return clks_syscall_exec_path(frame->rbx);
+    case CLKS_SYSCALL_EXEC_PATHV:
+        return clks_syscall_exec_pathv(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_EXEC_PATHV_IO:
+        return clks_syscall_exec_pathv_io(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_EXEC_REQUESTS:
+        return clks_exec_request_count();
+    case CLKS_SYSCALL_EXEC_SUCCESS:
+        return clks_exec_success_count();
+    case CLKS_SYSCALL_USER_SHELL_READY:
+        return (clks_userland_shell_ready() == CLKS_TRUE) ? 1ULL : 0ULL;
+    case CLKS_SYSCALL_USER_EXEC_REQUESTED:
+        return (clks_userland_shell_exec_requested() == CLKS_TRUE) ? 1ULL : 0ULL;
+    case CLKS_SYSCALL_USER_LAUNCH_TRIES:
+        return clks_userland_launch_attempts();
+    case CLKS_SYSCALL_USER_LAUNCH_OK:
+        return clks_userland_launch_success();
+    case CLKS_SYSCALL_USER_LAUNCH_FAIL:
+        return clks_userland_launch_failures();
+    case CLKS_SYSCALL_TTY_COUNT:
+        return (u64)clks_tty_count();
+    case CLKS_SYSCALL_TTY_ACTIVE:
+        return (u64)clks_tty_active();
+    case CLKS_SYSCALL_TTY_SWITCH:
+        clks_tty_switch((u32)frame->rbx);
+        return (u64)clks_tty_active();
+    case CLKS_SYSCALL_TTY_WRITE:
+        return clks_syscall_tty_write(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_TTY_WRITE_CHAR:
+        return clks_syscall_tty_write_char(frame->rbx);
+    case CLKS_SYSCALL_KBD_GET_CHAR:
+        return clks_syscall_kbd_get_char();
+    case CLKS_SYSCALL_FS_STAT_TYPE:
+        return clks_syscall_fs_stat_type(frame->rbx);
+    case CLKS_SYSCALL_FS_STAT_SIZE:
+        return clks_syscall_fs_stat_size(frame->rbx);
+    case CLKS_SYSCALL_FS_MKDIR:
+        return clks_syscall_fs_mkdir(frame->rbx);
+    case CLKS_SYSCALL_FS_WRITE:
+        return clks_syscall_fs_write(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_FS_APPEND:
+        return clks_syscall_fs_append(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_FS_REMOVE:
+        return clks_syscall_fs_remove(frame->rbx);
+    case CLKS_SYSCALL_LOG_JOURNAL_COUNT:
+        return clks_syscall_log_journal_count();
+    case CLKS_SYSCALL_LOG_JOURNAL_READ:
+        return clks_syscall_log_journal_read(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_KBD_BUFFERED:
+        return clks_keyboard_buffered_count();
+    case CLKS_SYSCALL_KBD_PUSHED:
+        return clks_keyboard_push_count();
+    case CLKS_SYSCALL_KBD_POPPED:
+        return clks_keyboard_pop_count();
+    case CLKS_SYSCALL_KBD_DROPPED:
+        return clks_keyboard_drop_count();
+    case CLKS_SYSCALL_KBD_HOTKEY_SWITCHES:
+        return clks_keyboard_hotkey_switch_count();
+    case CLKS_SYSCALL_GETPID:
+        return clks_syscall_getpid();
+    case CLKS_SYSCALL_SPAWN_PATH:
+        return clks_syscall_spawn_path(frame->rbx);
+    case CLKS_SYSCALL_SPAWN_PATHV:
+        return clks_syscall_spawn_pathv(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_WAITPID:
+        return clks_syscall_waitpid(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_PROC_ARGC:
+        return clks_syscall_proc_argc();
+    case CLKS_SYSCALL_PROC_ARGV:
+        return clks_syscall_proc_argv(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_PROC_ENVC:
+        return clks_syscall_proc_envc();
+    case CLKS_SYSCALL_PROC_ENV:
+        return clks_syscall_proc_env(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_PROC_LAST_SIGNAL:
+        return clks_syscall_proc_last_signal();
+    case CLKS_SYSCALL_PROC_FAULT_VECTOR:
+        return clks_syscall_proc_fault_vector();
+    case CLKS_SYSCALL_PROC_FAULT_ERROR:
+        return clks_syscall_proc_fault_error();
+    case CLKS_SYSCALL_PROC_FAULT_RIP:
+        return clks_syscall_proc_fault_rip();
+    case CLKS_SYSCALL_PROC_COUNT:
+        return clks_syscall_proc_count();
+    case CLKS_SYSCALL_PROC_PID_AT:
+        return clks_syscall_proc_pid_at(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_PROC_SNAPSHOT:
+        return clks_syscall_proc_snapshot(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_PROC_KILL:
+        return clks_syscall_proc_kill(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_EXIT:
+        return clks_syscall_exit(frame->rbx);
+    case CLKS_SYSCALL_SLEEP_TICKS:
+        return clks_syscall_sleep_ticks(frame->rbx);
+    case CLKS_SYSCALL_YIELD:
+        return clks_syscall_yield();
+    case CLKS_SYSCALL_SHUTDOWN:
+        return clks_syscall_shutdown();
+    case CLKS_SYSCALL_RESTART:
+        return clks_syscall_restart();
+    case CLKS_SYSCALL_AUDIO_AVAILABLE:
+        return clks_syscall_audio_available();
+    case CLKS_SYSCALL_AUDIO_PLAY_TONE:
+        return clks_syscall_audio_play_tone(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_AUDIO_STOP:
+        return clks_syscall_audio_stop();
+    case CLKS_SYSCALL_KDBG_SYM:
+        return clks_syscall_kdbg_sym(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_KDBG_BT:
+        return clks_syscall_kdbg_bt(frame->rbx);
+    case CLKS_SYSCALL_KDBG_REGS:
+        return clks_syscall_kdbg_regs(frame->rbx, frame->rcx);
+    case CLKS_SYSCALL_STATS_TOTAL:
+        return clks_syscall_stats_total_count();
+    case CLKS_SYSCALL_STATS_ID_COUNT:
+        return clks_syscall_stats_id(frame->rbx);
+    case CLKS_SYSCALL_STATS_RECENT_WINDOW:
+        return clks_syscall_stats_recent_window();
+    case CLKS_SYSCALL_STATS_RECENT_ID:
+        return clks_syscall_stats_recent_id(frame->rbx);
+    case CLKS_SYSCALL_FD_OPEN:
+        return clks_syscall_fd_open(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_FD_READ:
+        return clks_syscall_fd_read(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_FD_WRITE:
+        return clks_syscall_fd_write(frame->rbx, frame->rcx, frame->rdx);
+    case CLKS_SYSCALL_FD_CLOSE:
+        return clks_syscall_fd_close(frame->rbx);
+    case CLKS_SYSCALL_FD_DUP:
+        return clks_syscall_fd_dup(frame->rbx);
+    case CLKS_SYSCALL_DL_OPEN:
+        return clks_syscall_dl_open(frame->rbx);
+    case CLKS_SYSCALL_DL_CLOSE:
+        return clks_syscall_dl_close(frame->rbx);
+    case CLKS_SYSCALL_DL_SYM:
+        return clks_syscall_dl_sym(frame->rbx, frame->rcx);
+    default:
+        return (u64)-1;
    }
 }

 u64 clks_syscall_invoke_kernel(u64 id, u64 arg0, u64 arg1, u64 arg2) {
    u64 ret;

-    __asm__ volatile(
-        "int $0x80"
-        : "=a"(ret)
-        : "a"(id), "b"(arg0), "c"(arg1), "d"(arg2)
-        : "memory"
-    );
+    __asm__ volatile("int $0x80" : "=a"(ret) : "a"(id), "b"(arg0), "c"(arg1), "d"(arg2) : "memory");

    return ret;
 }
--- a/clks/kernel/tty.c
+++ b/clks/kernel/tty.c
@@ -69,12 +69,9 @@ static clks_bool clks_tty_scrollback_is_active(u32 tty_index);
 static void clks_tty_redraw_active(void);

 static u32 clks_tty_ansi_palette(u32 index) {
-    static const u32 palette[16] = {
-        0x00000000U, 0x00CD3131U, 0x000DBC79U, 0x00E5E510U,
-        0x002472C8U, 0x00BC3FBCU, 0x0011A8CDU, 0x00E5E5E5U,
-        0x00666666U, 0x00F14C4CU, 0x0023D18BU, 0x00F5F543U,
-        0x003B8EEAU, 0x00D670D6U, 0x0029B8DBU, 0x00FFFFFFU
-    };
+    static const u32 palette[16] = {0x00000000U, 0x00CD3131U, 0x000DBC79U, 0x00E5E510U, 0x002472C8U, 0x00BC3FBCU,
+                                    0x0011A8CDU, 0x00E5E5E5U, 0x00666666U, 0x00F14C4CU, 0x0023D18BU, 0x00F5F543U,
+                                    0x003B8EEAU, 0x00D670D6U, 0x0029B8DBU, 0x00FFFFFFU};

    if (index < 16U) {
        return palette[index];
@@ -88,25 +85,12 @@ static void clks_tty_reset_blink_timer(void) {
 }

 static void clks_tty_draw_cell_with_colors(u32 row, u32 col, char ch, u32 fg, u32 bg, u8 style) {
-    clks_fb_draw_char_styled(
-        col * clks_tty_cell_width,
-        row * clks_tty_cell_height,
-        ch,
-        fg,
-        bg,
-        (u32)style
-    );
+    clks_fb_draw_char_styled(col * clks_tty_cell_width, row * clks_tty_cell_height, ch, fg, bg, (u32)style);
 }

 static void clks_tty_draw_cell(u32 tty_index, u32 row, u32 col) {
-    clks_tty_draw_cell_with_colors(
-        row,
-        col,
-        clks_tty_cells[tty_index][row][col],
-        clks_tty_cell_fg[tty_index][row][col],
-        clks_tty_cell_bg[tty_index][row][col],
-        clks_tty_cell_style[tty_index][row][col]
-    );
+    clks_tty_draw_cell_with_colors(row, col, clks_tty_cells[tty_index][row][col], clks_tty_cell_fg[tty_index][row][col],
+                                   clks_tty_cell_bg[tty_index][row][col], clks_tty_cell_style[tty_index][row][col]);
 }

 static void clks_tty_dirty_reset(void) {
@@ -189,21 +173,11 @@ static void clks_tty_scrollback_push_row(u32 tty_index, u32 row) {
    u32 slot = clks_tty_scrollback_head[tty_index];

    clks_memcpy(clks_tty_scrollback_cells[tty_index][slot], clks_tty_cells[tty_index][row], clks_tty_cols);
-    clks_memcpy(
-        clks_tty_scrollback_fg[tty_index][slot],
-        clks_tty_cell_fg[tty_index][row],
-        (usize)clks_tty_cols * sizeof(u32)
-    );
-    clks_memcpy(
-        clks_tty_scrollback_bg[tty_index][slot],
-        clks_tty_cell_bg[tty_index][row],
-        (usize)clks_tty_cols * sizeof(u32)
-    );
-    clks_memcpy(
-        clks_tty_scrollback_style[tty_index][slot],
-        clks_tty_cell_style[tty_index][row],
-        clks_tty_cols
-    );
+    clks_memcpy(clks_tty_scrollback_fg[tty_index][slot], clks_tty_cell_fg[tty_index][row],
+                (usize)clks_tty_cols * sizeof(u32));
+    clks_memcpy(clks_tty_scrollback_bg[tty_index][slot], clks_tty_cell_bg[tty_index][row],
+                (usize)clks_tty_cols * sizeof(u32));
+    clks_memcpy(clks_tty_scrollback_style[tty_index][slot], clks_tty_cell_style[tty_index][row], clks_tty_cols);

    clks_tty_scrollback_head[tty_index] = (slot + 1U) % CLKS_TTY_SCROLLBACK_LINES;

@@ -338,14 +312,8 @@ static void clks_tty_draw_status_bar(void) {
    for (col = 0U; col < clks_tty_cols; col++) {
        char ch = (col < CLKS_TTY_MAX_COLS) ? line[col] : ' ';

-        clks_tty_draw_cell_with_colors(
-            status_row,
-            col,
-            ch,
-            CLKS_TTY_STATUS_FG,
-            CLKS_TTY_STATUS_BG,
-            CLKS_TTY_STATUS_STYLE
-        );
+        clks_tty_draw_cell_with_colors(status_row, col, ch, CLKS_TTY_STATUS_FG, CLKS_TTY_STATUS_BG,
+                                       CLKS_TTY_STATUS_STYLE);
    }
 }

@@ -470,14 +438,10 @@ static void clks_tty_redraw_active(void) {
            u32 phys = clks_tty_scrollback_logical_to_physical(tty_index, doc_index);

            for (col = 0; col < clks_tty_cols; col++) {
-                clks_tty_draw_cell_with_colors(
-                    row,
-                    col,
-                    clks_tty_scrollback_cells[tty_index][phys][col],
-                    clks_tty_scrollback_fg[tty_index][phys][col],
-                    clks_tty_scrollback_bg[tty_index][phys][col],
-                    clks_tty_scrollback_style[tty_index][phys][col]
-                );
+                clks_tty_draw_cell_with_colors(row, col, clks_tty_scrollback_cells[tty_index][phys][col],
+                                               clks_tty_scrollback_fg[tty_index][phys][col],
+                                               clks_tty_scrollback_bg[tty_index][phys][col],
+                                               clks_tty_scrollback_style[tty_index][phys][col]);
            }

            continue;
@@ -492,13 +456,8 @@ static void clks_tty_redraw_active(void) {

            for (col = 0; col < clks_tty_cols; col++) {
                clks_tty_draw_cell_with_colors(
-                    row,
-                    col,
-                    clks_tty_cells[tty_index][src_row][col],
-                    clks_tty_cell_fg[tty_index][src_row][col],
-                    clks_tty_cell_bg[tty_index][src_row][col],
-                    clks_tty_cell_style[tty_index][src_row][col]
-                );
+                    row, col, clks_tty_cells[tty_index][src_row][col], clks_tty_cell_fg[tty_index][src_row][col],
+                    clks_tty_cell_bg[tty_index][src_row][col], clks_tty_cell_style[tty_index][src_row][col]);
            }
        }
    }
@@ -516,21 +475,11 @@ static void clks_tty_scroll_up(u32 tty_index) {

    for (row = 1; row < clks_tty_content_rows(); row++) {
        clks_memcpy(clks_tty_cells[tty_index][row - 1U], clks_tty_cells[tty_index][row], clks_tty_cols);
-        clks_memcpy(
-            clks_tty_cell_fg[tty_index][row - 1U],
-            clks_tty_cell_fg[tty_index][row],
-            (usize)clks_tty_cols * sizeof(u32)
-        );
-        clks_memcpy(
-            clks_tty_cell_bg[tty_index][row - 1U],
-            clks_tty_cell_bg[tty_index][row],
-            (usize)clks_tty_cols * sizeof(u32)
-        );
-        clks_memcpy(
-            clks_tty_cell_style[tty_index][row - 1U],
-            clks_tty_cell_style[tty_index][row],
-            clks_tty_cols
-        );
+        clks_memcpy(clks_tty_cell_fg[tty_index][row - 1U], clks_tty_cell_fg[tty_index][row],
+                    (usize)clks_tty_cols * sizeof(u32));
+        clks_memcpy(clks_tty_cell_bg[tty_index][row - 1U], clks_tty_cell_bg[tty_index][row],
+                    (usize)clks_tty_cols * sizeof(u32));
+        clks_memcpy(clks_tty_cell_style[tty_index][row - 1U], clks_tty_cell_style[tty_index][row], clks_tty_cols);
    }

    clks_tty_fill_row(tty_index, clks_tty_content_rows() - 1U, ' ');
@@ -1462,7 +1411,6 @@ void clks_tty_scrollback_page_down(void) {
    }
 }

-
 u32 clks_tty_active(void) {
    return clks_tty_active_index;
 }
@@ -1474,4 +1422,3 @@ u32 clks_tty_count(void) {
 clks_bool clks_tty_ready(void) {
    return clks_tty_is_ready;
 }
-
--- a/clks/kernel/userland.c
+++ b/clks/kernel/userland.c
@@ -136,8 +136,7 @@ clks_bool clks_userland_init(void) {
 }

 void clks_userland_tick(u64 tick) {
-    if (clks_user_shell_exec_enabled == CLKS_FALSE ||
-        clks_user_shell_ready == CLKS_FALSE ||
+    if (clks_user_shell_exec_enabled == CLKS_FALSE || clks_user_shell_ready == CLKS_FALSE ||
        clks_user_shell_exec_requested_flag == CLKS_TRUE) {
        return;
    }