Autoformat

22 files changed, 309 insertions, 296 deletions

diff --git a/.clang-format b/.clang-format
index f6e12ca..863c901 100644
--- a/.clang-format
+++ b/.clang-format
@@ -4,4 +4,6 @@ IndentWidth: 4
 SpaceAfterCStyleCast: true
 AlignConsecutiveMacros: true
 AlignConsecutiveBitFields: true
+IndentCaseLabels: false
+PointerAlignment: Right
 ---
diff --git a/kern/Makefile b/kern/Makefile
index acb5f86..b3ef1ab 100644
--- a/kern/Makefile
+++ b/kern/Makefile
@@ -34,7 +34,7 @@ install: kern.bin
 	pi-install $<
 
 clean:
-	rm -f *.d *.list *.o *.elf *.bin
+	rm -rf *.d *.list *.o *.elf *.bin .deps
 
 -include $(DEP)
 
diff --git a/kern/boot.c b/kern/boot.c
index c840bd8..a7a252a 100644
--- a/kern/boot.c
+++ b/kern/boot.c
@@ -20,10 +20,10 @@ extern void __attribute__((section(".text.boot"))) _hlt();
 
 // map va to pa in the kernel pagetable
 static void vm_kernel_map(uintptr_t va, uintptr_t pa) {
-    pte_1mb_t* pgtbl = (pte_1mb_t*) ka2pa((uintptr_t) kernel_pagetable);
+    pte_1mb_t *pgtbl = (pte_1mb_t *) ka2pa((uintptr_t) kernel_pagetable);
 
     unsigned pte_idx = va >> 20;
-    pte_1mb_t* pte = &pgtbl[pte_idx];
+    pte_1mb_t *pte = &pgtbl[pte_idx];
 
     if (pte->tag != 0b00) {
         _hlt();
@@ -68,8 +68,8 @@ static void vm_kernel_enable() {
 
 void cstart() {
     extern int _kbss_start, _kbss_end;
-    int* bss = (int*) ka2pa((uintptr_t) &_kbss_start);
-    int* bss_end = (int*) ka2pa((uintptr_t) &_kbss_end);
+    int *bss = (int *) ka2pa((uintptr_t) &_kbss_start);
+    int *bss_end = (int *) ka2pa((uintptr_t) &_kbss_end);
     while (bss < bss_end) {
         *bss++ = 0;
     }
diff --git a/kern/gpio.c b/kern/gpio.c
index 13e0671..b44c2cb 100644
--- a/kern/gpio.c
+++ b/kern/gpio.c
@@ -6,14 +6,14 @@
 #include "interrupts.h"
 #include "timer.h"
 
-static volatile uint32_t* gpio_fsel = (uint32_t*) (GPIO_BASE);
-static volatile uint32_t* gpio_eds = (uint32_t*) (GPIO_BASE + 0x40);
-static volatile uint32_t* gpio_ren = (uint32_t*) (GPIO_BASE + 0x4c);
-static volatile uint32_t* gpio_fen = (uint32_t*) (GPIO_BASE + 0x58);
-static volatile uint32_t* gpio_aren = (uint32_t*) (GPIO_BASE + 0x7c);
-static volatile uint32_t* gpio_afen = (uint32_t*) (GPIO_BASE + 0x88);
-static volatile uint32_t* gpio_pud = (uint32_t*) (GPIO_BASE + 0x94);
-static volatile uint32_t* gpio_pudclk = (uint32_t*) (GPIO_BASE + 0x98);
+static volatile uint32_t *gpio_fsel = (uint32_t *) (GPIO_BASE);
+static volatile uint32_t *gpio_eds = (uint32_t *) (GPIO_BASE + 0x40);
+static volatile uint32_t *gpio_ren = (uint32_t *) (GPIO_BASE + 0x4c);
+static volatile uint32_t *gpio_fen = (uint32_t *) (GPIO_BASE + 0x58);
+static volatile uint32_t *gpio_aren = (uint32_t *) (GPIO_BASE + 0x7c);
+static volatile uint32_t *gpio_afen = (uint32_t *) (GPIO_BASE + 0x88);
+static volatile uint32_t *gpio_pud = (uint32_t *) (GPIO_BASE + 0x94);
+static volatile uint32_t *gpio_pudclk = (uint32_t *) (GPIO_BASE + 0x98);
 
 void gpio_set_func(unsigned pin, gpio_func_t fn) {
     if (pin >= 32)
diff --git a/kern/gpio.h b/kern/gpio.h
index c42bcd9..15161d2 100644
--- a/kern/gpio.h
+++ b/kern/gpio.h
@@ -25,9 +25,9 @@ typedef enum {
 
 #define GPIO_BASE pa2ka(0x20200000U)
 
-static volatile uint32_t* gpio_set = (uint32_t*) (GPIO_BASE + 0x1C);
-static volatile uint32_t* gpio_clr = (uint32_t*) (GPIO_BASE + 0x28);
-static volatile uint32_t* gpio_lev = (uint32_t*) (GPIO_BASE + 0x34);
+static volatile uint32_t *gpio_set = (uint32_t *) (GPIO_BASE + 0x1C);
+static volatile uint32_t *gpio_clr = (uint32_t *) (GPIO_BASE + 0x28);
+static volatile uint32_t *gpio_lev = (uint32_t *) (GPIO_BASE + 0x34);
 
 void gpio_set_func(unsigned pin, gpio_func_t fn);
 void gpio_set_output(unsigned pin);
diff --git a/kern/interrupts.c b/kern/interrupts.c
index 704f120..f211398 100644
--- a/kern/interrupts.c
+++ b/kern/interrupts.c
@@ -19,7 +19,7 @@ typedef struct {
     uint32_t disable_basic_irqs;
 } irq_ctrl_t;
 
-static volatile irq_ctrl_t* const irq_ctrl = (irq_ctrl_t*) pa2ka(0x2000B200);
+static volatile irq_ctrl_t *const irq_ctrl = (irq_ctrl_t *) pa2ka(0x2000B200);
 
 void irq_enable_basic(uint32_t irq) {
     irq_ctrl->enable_basic_irqs = bit_set(irq_ctrl->enable_basic_irqs, irq);
@@ -65,8 +65,8 @@ void irq_init_table(uintptr_t addr) {
     extern char _interrupt_table;
     extern char _interrupt_table_end;
 
-    char* dst = (char*) addr;
-    char* src = (char*) &_interrupt_table;
+    char *dst = (char *) addr;
+    char *src = (char *) &_interrupt_table;
     size_t n = &_interrupt_table_end - src;
     memcpy(dst, src, n);
 
@@ -75,7 +75,7 @@ void irq_init_table(uintptr_t addr) {
 
 extern uintptr_t _vector_table;
 
-static volatile uintptr_t* const vec_tbl = (uintptr_t*) &_vector_table;
+static volatile uintptr_t *const vec_tbl = (uintptr_t *) &_vector_table;
 
 void register_irq_vec(irq_vec_t vec, uintptr_t fn) {
     vec_tbl[vec] = fn;
diff --git a/kern/kern.c b/kern/kern.c
index 5950b66..b26146b 100644
--- a/kern/kern.c
+++ b/kern/kern.c
@@ -4,19 +4,19 @@
 #include "gpio.h"
 #include "interrupts.h"
 #include "kern.h"
+#include "kmalloc.h"
 #include "ksan.h"
+#include "proc.h"
 #include "sys.h"
 #include "uart.h"
 #include "vm.h"
-#include "proc.h"
-#include "kmalloc.h"
 
 void reboot() {
     printf("DONE!!!\n");
     uart_tx_flush();
 
-    volatile uint32_t* PM_RSTC = (uint32_t*) pa2ka(0x2010001c);
-    volatile uint32_t* PM_WDOG = (uint32_t*) pa2ka(0x20100024);
+    volatile uint32_t *PM_RSTC = (uint32_t *) pa2ka(0x2010001c);
+    volatile uint32_t *PM_WDOG = (uint32_t *) pa2ka(0x20100024);
 
     const int PM_PASSWORD = 0x5a000000;
     const int PM_RSTC_WRCFG_FULL_RESET = 0x00000020;
diff --git a/kern/kmalloc.c b/kern/kmalloc.c
index a087efc..4054c21 100644
--- a/kern/kmalloc.c
+++ b/kern/kmalloc.c
@@ -3,9 +3,9 @@
 
 #include "kern.h"
 #include "kmalloc.h"
+#include "ksan.h"
 #include "lib.h"
 #include "vm.h"
-#include "ksan.h"
 
 // allocates pages of size 4096
 #define MIN_ORDER 12
@@ -17,14 +17,14 @@ typedef struct {
 } phys_page_t;
 
 typedef struct free_page {
-    struct free_page* next;
-    struct free_page* prev;
+    struct free_page *next;
+    struct free_page *prev;
 } free_page_t;
 
 // free list for each type of order
-static free_page_t* free_lists[MAX_ORDER + 1];
+static free_page_t *free_lists[MAX_ORDER + 1];
 
-static void ll_free_insert(free_page_t* n, int order) {
+static void ll_free_insert(free_page_t *n, int order) {
     n->next = free_lists[order];
     n->prev = NULL;
     if (free_lists[order])
@@ -32,7 +32,7 @@ static void ll_free_insert(free_page_t* n, int order) {
     free_lists[order] = n;
 }
 
-static void ll_free_remove(free_page_t* n, int order) {
+static void ll_free_remove(free_page_t *n, int order) {
     if (n->next)
         n->next->prev = n->prev;
     if (n->prev)
@@ -63,8 +63,8 @@ static uintptr_t get_buddy(uintptr_t pn) {
     return pagenum(pa - (1 << p.order));
 }
 
-static free_page_t* pn_to_free(uintptr_t pn) {
-    return (free_page_t*) pa2ka(pageaddr(pn));
+static free_page_t *pn_to_free(uintptr_t pn) {
+    return (free_page_t *) pa2ka(pageaddr(pn));
 }
 
 extern char _kheap_start;
@@ -111,7 +111,7 @@ void kmalloc_init() {
 
 // Allocate and returns a pointer to at least `sz` contiguous bytes of memory.
 // Returns `NULL` if `sz == 0` or on failure.
-void* kmalloc(size_t sz) {
+void *kmalloc(size_t sz) {
     if (sz == 0) {
         return NULL;
     }
@@ -143,7 +143,7 @@ void* kmalloc(size_t sz) {
                     asan_mark_memory(pa, sz, true);
 #endif
 
-                    return (void*) pa2ka(pa);
+                    return (void *) pa2ka(pa);
                 } else if (i > order) {
                     // We found a block that is greater than the requested
                     // order so there are no blocks with the correct size. We
@@ -171,8 +171,8 @@ void* kmalloc(size_t sz) {
 
 // Free a pointer previously returned by `kalloc`. Does nothing if `ptr ==
 // NULL`.
-void kfree(void* ptr) {
-    if (!ptr || (char*) ptr < &_kheap_start) {
+void kfree(void *ptr) {
+    if (!ptr || (char *) ptr < &_kheap_start) {
         return;
     }
 
diff --git a/kern/kmalloc.h b/kern/kmalloc.h
index bfbc168..ddf503b 100644
--- a/kern/kmalloc.h
+++ b/kern/kmalloc.h
@@ -6,9 +6,9 @@
 #include "kern.h"
 
 void kmalloc_init();
-void* kmalloc(size_t size);
-void* kmalloc_aligned(size_t size, size_t align);
-void kfree(void* p);
+void *kmalloc(size_t size);
+void *kmalloc_aligned(size_t size, size_t align);
+void kfree(void *p);
 
 static inline uintptr_t pagenum(uintptr_t pa) {
     return pa / PAGESIZE;
diff --git a/kern/ksan.c b/kern/ksan.c
index 77a68a1..6724d1f 100644
--- a/kern/ksan.c
+++ b/kern/ksan.c
@@ -3,12 +3,12 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#include "vm.h"
 #include "kern.h"
 #include "kmalloc.h"
+#include "vm.h"
 
 typedef struct {
-    const char* file;
+    const char *file;
     uint32_t line;
     uint32_t col;
 } src_loc_t;
@@ -21,14 +21,14 @@ typedef struct {
 
 typedef struct {
     src_loc_t loc;
-    const type_desc_t* array_type;
-    const type_desc_t* index_type;
+    const type_desc_t *array_type;
+    const type_desc_t *index_type;
 } out_of_bounds_t;
 
 typedef struct {
     src_loc_t loc;
-    const type_desc_t* lhs_type;
-    const type_desc_t* rhs_type;
+    const type_desc_t *lhs_type;
+    const type_desc_t *rhs_type;
 } shift_out_of_bounds_t;
 
 typedef struct {
@@ -39,12 +39,12 @@ typedef struct {
 
 typedef struct {
     src_loc_t loc;
-    const type_desc_t* type;
+    const type_desc_t *type;
 } type_data_t;
 
 typedef struct {
     src_loc_t loc;
-    type_desc_t* type;
+    type_desc_t *type;
     uint8_t alignment;
     uint8_t type_check_kind;
 } type_mismatch_t;
@@ -53,88 +53,88 @@ typedef type_data_t overflow_t;
 typedef type_data_t invalid_value_t;
 typedef type_data_t vla_bound_t;
 
-static void handle_overflow(overflow_t* data,
+static void handle_overflow(overflow_t *data,
                             unsigned long lhs,
                             unsigned long rhs,
                             char op) {
     panic("%s:%lu: integer overflow\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_add_overflow(overflow_t* data,
+void __ubsan_handle_add_overflow(overflow_t *data,
                                  unsigned long a,
                                  unsigned long b) {
     handle_overflow(data, a, b, '+');
 }
 
-void __ubsan_handle_sub_overflow(overflow_t* data,
+void __ubsan_handle_sub_overflow(overflow_t *data,
                                  unsigned long a,
                                  unsigned long b) {
     handle_overflow(data, a, b, '-');
 }
 
-void __ubsan_handle_mul_overflow(overflow_t* data,
+void __ubsan_handle_mul_overflow(overflow_t *data,
                                  unsigned long a,
                                  unsigned long b) {
     handle_overflow(data, a, b, '*');
 }
 
-void __ubsan_handle_negate_overflow(overflow_t* data, unsigned long a) {
+void __ubsan_handle_negate_overflow(overflow_t *data, unsigned long a) {
     panic("%s:%lu: negate overflow\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_divrem_overflow(overflow_t* data,
+void __ubsan_handle_divrem_overflow(overflow_t *data,
                                     unsigned long a,
                                     unsigned long b) {
     panic("%s:%lu: divrem overflow\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_shift_out_of_bounds(shift_out_of_bounds_t* data,
+void __ubsan_handle_shift_out_of_bounds(shift_out_of_bounds_t *data,
                                         unsigned long a,
                                         unsigned long b) {
     panic("%s:%lu: shift out of bounds\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_type_mismatch(type_mismatch_t* data, unsigned long addr) {
+void __ubsan_handle_type_mismatch(type_mismatch_t *data, unsigned long addr) {
     panic("%s:%lu: type mismatch: %lx\n", data->loc.file, data->loc.line, addr);
 }
 
-void __ubsan_handle_type_mismatch_v1(type_mismatch_t* data,
+void __ubsan_handle_type_mismatch_v1(type_mismatch_t *data,
                                      unsigned long addr) {
     panic("%s:%lu: type mismatch v1: %lx, %d, %d\n", data->loc.file,
           data->loc.line, addr, data->type_check_kind, data->alignment);
 }
 
-void __ubsan_handle_out_of_bounds(out_of_bounds_t* data, unsigned long index) {
+void __ubsan_handle_out_of_bounds(out_of_bounds_t *data, unsigned long index) {
     panic("%s:%lu: out of bounds\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_builtin_unreachable(src_loc_t* loc) {
+void __ubsan_handle_builtin_unreachable(src_loc_t *loc) {
     panic("%s:%lu: unreachable\n", loc->file, loc->line);
 }
 
-void __ubsan_handle_missing_return(src_loc_t* loc) {
+void __ubsan_handle_missing_return(src_loc_t *loc) {
     panic("%s:%lu: missing return\n", loc->file, loc->line);
 }
 
-void __ubsan_handle_vla_bound_not_positive(vla_bound_t* data,
+void __ubsan_handle_vla_bound_not_positive(vla_bound_t *data,
                                            unsigned long bound) {
     panic("%s:%lu: vla bound not positive\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_load_invalid_value(invalid_value_t* data,
+void __ubsan_handle_load_invalid_value(invalid_value_t *data,
                                        unsigned long val) {
     panic("%s:%lu: load invalid value\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_nonnull_arg(nonnull_arg_t* data) {
+void __ubsan_handle_nonnull_arg(nonnull_arg_t *data) {
     panic("%s:%lu: nonnull arg\n", data->loc.file, data->loc.line);
 }
 
-void __ubsan_handle_nonnull_return(src_loc_t* loc) {
+void __ubsan_handle_nonnull_return(src_loc_t *loc) {
     panic("%s:%lu: nonnull return\n", loc->file, loc->line);
 }
 
-void __ubsan_handle_pointer_overflow(src_loc_t* loc,
+void __ubsan_handle_pointer_overflow(src_loc_t *loc,
                                      uintptr_t base,
                                      uintptr_t result) {
     panic("%s:%lu: pointer overflow\n", loc->file, loc->line);
@@ -145,7 +145,7 @@ static bool asan_pagemap[MEMSIZE_PHYSICAL / PAGESIZE];
 
 static bool asan = false;
 
-static bool in_range(uintptr_t ka, char* start, char* end) {
+static bool in_range(uintptr_t ka, char *start, char *end) {
     return ka >= (uintptr_t) start && ka < (uintptr_t) end;
 }
 
@@ -217,7 +217,7 @@ void __asan_storeN_noabort(unsigned long addr, size_t sz) {
 }
 
 void __asan_handle_no_return() {}
-void __asan_before_dynamic_init(const char* module_name) {}
+void __asan_before_dynamic_init(const char *module_name) {}
 void __asan_after_dynamic_init() {}
 
 void asan_enable() {
diff --git a/kern/proc.c b/kern/proc.c
index dde18c3..b78f111 100644
--- a/kern/proc.c
+++ b/kern/proc.c
@@ -1,14 +1,14 @@
-#include "kern.h"
 #include "proc.h"
-#include "vm.h"
+#include "kern.h"
 #include "kmalloc.h"
+#include "vm.h"
 
 static pid_t id;
 
 proc_t procs[NPROC];
-proc_t* curproc;
+proc_t *curproc;
 
-proc_t *proc_new(uint8_t* code, size_t codesz) {
+proc_t *proc_new(uint8_t *code, size_t codesz) {
     proc_t *proc = &procs[id];
     proc->id = id++;
     proc->pt = kalloc_pt();
@@ -25,18 +25,19 @@ proc_t *proc_new(uint8_t* code, size_t codesz) {
     vm_map(proc->pt, pa2ka(0x20100000), 0x20100000, PAGE_1MB, RW_USER);
     vm_map(proc->pt, pa2ka(0x20200000), 0x20200000, PAGE_1MB, RW_USER);
     // map proc code into pt
-    void* pgs = kmalloc(proc->codesz);
+    void *pgs = kmalloc(proc->codesz);
     memcpy(pgs, proc->code, proc->codesz);
     for (size_t n = 0; n < proc->codesz; n += SIZE_4KB) {
-        vm_map(proc->pt, PROC_ENTRY + n, ka2pa((uintptr_t) pgs + n), PAGE_4KB, RW_USER);
+        vm_map(proc->pt, PROC_ENTRY + n, ka2pa((uintptr_t) pgs + n), PAGE_4KB,
+               RW_USER);
     }
     proc->regs.pc = PROC_ENTRY;
     return proc;
 }
 
-#include "sys.h"
 #include "asm.h"
-void __attribute__((noreturn)) proc_run(proc_t* proc) {
+#include "sys.h"
+void __attribute__((noreturn)) proc_run(proc_t *proc) {
     proc->state = PROC_RUNNING;
     vm_set_pt(proc->pt);
     curproc = proc;
@@ -45,6 +46,7 @@ void __attribute__((noreturn)) proc_run(proc_t* proc) {
     // TODO(masot): add an assert like that
     sys_set_domain(DOM_CLIENT);
     set_spsr((get_cpsr() & ~0b11111) | 0b10000);
-    asm volatile ("ldm %0, {r0-r15}^" : : "r"(proc));
-    while (1) {}
+    asm volatile("ldm %0, {r0-r15}^" : : "r"(proc));
+    while (1) {
+    }
 }
diff --git a/kern/proc.h b/kern/proc.h
index 621260b..d908d56 100644
--- a/kern/proc.h
+++ b/kern/proc.h
@@ -6,7 +6,7 @@
 #include "vm.h"
 
 #define PROC_ENTRY 0x8000
-#define NPROC 16
+#define NPROC      16
 
 typedef struct {
     uint32_t r0;
@@ -36,15 +36,15 @@ typedef enum {
 typedef struct {
     regs_t regs;
     uint32_t id;
-    pagetable_t* pt;
+    pagetable_t *pt;
 
-    uint8_t* code;
+    uint8_t *code;
     size_t codesz;
 
     proc_state_t state;
 } proc_t;
 
-extern proc_t* curproc;
+extern proc_t *curproc;
 
-proc_t *proc_new(uint8_t* code, size_t codesz);
-void proc_run(proc_t* proc);
+proc_t *proc_new(uint8_t *code, size_t codesz);
+void proc_run(proc_t *proc);
diff --git a/kern/syscall.c b/kern/syscall.c
index 35d61a4..b10d4e5 100644
--- a/kern/syscall.c
+++ b/kern/syscall.c
@@ -1,11 +1,11 @@
 #include <stdint.h>
 
 #include "kern.h"
-#include "syscall_list.h"
-#include "vm.h"
-#include "proc.h"
 #include "kmalloc.h"
+#include "proc.h"
 #include "sys.h"
+#include "syscall_list.h"
+#include "vm.h"
 
 #define VERBOSE_SYSCALLS 0
 #if VERBOSE_SYSCALLS
@@ -17,7 +17,7 @@
 unsigned syscall_alloc_page(uint32_t page_addr, uint32_t page_size) {
     assert(page_addr == SYSCALL_ARG_ANY_PAGE);
     dprintf("Got alloc page syscall for any page, 1MB long.\n");
-    uintptr_t ptr = (uintptr_t)ka2pa((uintptr_t)kmalloc(page_size));
+    uintptr_t ptr = (uintptr_t) ka2pa((uintptr_t) kmalloc(page_size));
     dprintf("Giving back physical page %x\n", ptr);
     return ptr;
 }
@@ -27,37 +27,37 @@ unsigned syscall_vm_map(uint32_t va,
                         uint32_t flags,
                         uint32_t page_size) {
     assert(flags == 0);
-    dprintf("Got VM_MAP syscall for va=%lx, pa=%lx, flags=%lx, 1MB.\n",
-            va, pa, flags);
+    dprintf("Got VM_MAP syscall for va=%lx, pa=%lx, flags=%lx, 1MB.\n", va, pa,
+            flags);
     // TODO(masot): FLAGS
     vm_map(curproc->pt, va, pa, page_size, RW_USER);
     vm_flushem();
     return 0;
 }
 
-void syscall(regs_t* regs) {
+void syscall(regs_t *regs) {
     unsigned sysno = regs->r0;
     switch (sysno) {
-        case SYSCALL_EXIT:
-            printf("Exiting with exit code %lu\n", regs->r1);
-            reboot();
-            break;
-
-        case SYSCALL_ALLOC_PAGE:
-            regs->r0 = syscall_alloc_page(regs->r1, regs->r2);
-            break;
-
-        case SYSCALL_DEALLOC_PAGE:
-            panic("SYSCALL_DEALLOC_PAGE");
-            break;
-
-        case SYSCALL_VM_MAP:
-            regs->r0 = syscall_vm_map(regs->r1, regs->r2, regs->r3, regs->r4);
-            break;
-
-        default:
-            panic("unhandled syscall %d\n", sysno);
-            break;
+    case SYSCALL_EXIT:
+        printf("Exiting with exit code %lu\n", regs->r1);
+        reboot();
+        break;
+
+    case SYSCALL_ALLOC_PAGE:
+        regs->r0 = syscall_alloc_page(regs->r1, regs->r2);
+        break;
+
+    case SYSCALL_DEALLOC_PAGE:
+        panic("SYSCALL_DEALLOC_PAGE");
+        break;
+
+    case SYSCALL_VM_MAP:
+        regs->r0 = syscall_vm_map(regs->r1, regs->r2, regs->r3, regs->r4);
+        break;
+
+    default:
+        panic("unhandled syscall %d\n", sysno);
+        break;
     }
     regs->pc += 4;
 }
diff --git a/kern/syscall_list.h b/kern/syscall_list.h
index 377a540..e22d70d 100644
--- a/kern/syscall_list.h
+++ b/kern/syscall_list.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#define SYSCALL_EXIT            0
-#define SYSCALL_ALLOC_PAGE      1
-#define SYSCALL_DEALLOC_PAGE    2
-#define SYSCALL_VM_MAP          3
+#define SYSCALL_EXIT         0
+#define SYSCALL_ALLOC_PAGE   1
+#define SYSCALL_DEALLOC_PAGE 2
+#define SYSCALL_VM_MAP       3
 
 // NOTE: DO NOT CHANGE THESE without changing vm.h
-#define SYSCALL_ARG_ANY_PAGE    0
-#define SIZE_4KB                (1 << 12)
-#define SIZE_16KB               (1 << 14)
-#define SIZE_1MB                (1 << 20)
-#define SIZE_16MB               (1 << 24)
+#define SYSCALL_ARG_ANY_PAGE 0
+#define SIZE_4KB             (1 << 12)
+#define SIZE_16KB            (1 << 14)
+#define SIZE_1MB             (1 << 20)
+#define SIZE_16MB            (1 << 24)
diff --git a/kern/u-syscall.h b/kern/u-syscall.h
index f07b999..ed27522 100644
--- a/kern/u-syscall.h
+++ b/kern/u-syscall.h
@@ -42,7 +42,7 @@ static inline void exit() {
 // to allocate any physical page. Returns the address of the allocated page; or
 // returns a null pointer if the requested page does not exist or is already
 // allocated, or if there are no available pages.
-static inline void* alloc_page(int i) {
+static inline void *alloc_page(int i) {
     // Mark which process allocated the page.
     return syscall_1(SYSCALL_ALLOC_PAGE, i);
 }
@@ -50,7 +50,7 @@ static inline void* alloc_page(int i) {
 // Release the allocated physical page. The caller needs to have been previously
 // allocated the physical page and not already deallocated it. Returns 0 if
 // successful, otherwise -1.
-static inline int dealloc_page(void* addr) {
+static inline int dealloc_page(void *addr) {
     return syscall_1(SYSCALL_DEALLOC_PAGE, addr);
 }
 
diff --git a/kern/uart.c b/kern/uart.c
index 305a525..e5403ba 100644
--- a/kern/uart.c
+++ b/kern/uart.c
@@ -28,8 +28,8 @@ typedef struct {
 #define CLEAR_FIFOS   (CLEAR_TX_FIFO | CLEAR_RX_FIFO)
 #define IIR_RESET     ((0b11 << 6) | 1)
 
-static volatile uint32_t* const aux_enables = (uint32_t*) pa2ka(0x20215004);
-static volatile aux_periphs_t* const uart = (aux_periphs_t*) pa2ka(0x20215040);
+static volatile uint32_t *const aux_enables = (uint32_t *) pa2ka(0x20215004);
+static volatile aux_periphs_t *const uart = (aux_periphs_t *) pa2ka(0x20215040);
 
 void uart_init(unsigned baud) {
     gpio_set_func(GPIO_TX, GPIO_FUNC_ALT5);
@@ -81,7 +81,7 @@ void uart_tx(uint8_t c) {
     dev_barrier();
 }
 
-void uart_putc(void* p, char c) {
+void uart_putc(void *p, char c) {
     (void) p;
     uart_tx(c);
 }
diff --git a/kern/uart.h b/kern/uart.h
index b2b32af..4efc756 100644
--- a/kern/uart.h
+++ b/kern/uart.h
@@ -15,4 +15,4 @@ bool uart_tx_empty();
 void uart_tx_flush();
 
 // for tinyprintf
-void uart_putc(void* p, char c);
+void uart_putc(void *p, char c);
diff --git a/kern/vm.c b/kern/vm.c
index c005cc2..eaf950a 100644
--- a/kern/vm.c
+++ b/kern/vm.c
@@ -1,78 +1,83 @@
 #include "vm.h"
+#include "bits.h"
 #include "kern.h"
-#include "sys.h"
 #include "kmalloc.h"
-#include "bits.h"
+#include "sys.h"
 
-pagetable_t* kalloc_pt() {
-    pagetable_t* l1pt = (pagetable_t*) kmalloc(sizeof(pagetable_t));
+pagetable_t *kalloc_pt() {
+    pagetable_t *l1pt = (pagetable_t *) kmalloc(sizeof(pagetable_t));
     assert(l1pt);
     memset(l1pt, 0, sizeof(pagetable_t));
     return l1pt;
 }
 
-static void init_second_level(pde_t* pde) {
-    pte_small_t* pgtbl = kmalloc(256 * sizeof(pte_small_t));
+static void init_second_level(pde_t *pde) {
+    pte_small_t *pgtbl = kmalloc(256 * sizeof(pte_small_t));
     assert(pgtbl);
     memset(pgtbl, 0, 256 * sizeof(pte_small_t));
     pde->addr = ka2pa((uintptr_t) pgtbl) >> 10;
     pde->tag = 0b01;
 }
 
-void vm_map(pagetable_t* pt, uintptr_t va, uintptr_t pa, pg_typ_t typ, protection_typ_t protection) {
+void vm_map(pagetable_t *pt,
+            uintptr_t va,
+            uintptr_t pa,
+            pg_typ_t typ,
+            protection_typ_t protection) {
     unsigned idx = va >> 20;
-    l1pte_t* l1pte = &pt->entries[idx];
+    l1pte_t *l1pte = &pt->entries[idx];
 
     // TODO: allow remapping
     assert(l1pte->pde.tag == 0);
 
     switch (typ) {
-        case PAGE_UNMAPPED:
-            l1pte->pde.tag = 0b00;
+    case PAGE_UNMAPPED:
+        l1pte->pde.tag = 0b00;
+        break;
+    case PAGE_1MB:
+        l1pte->pte_1mb.tag = 0b10;
+        l1pte->pte_1mb.sec_base_addr = pa >> 20;
+        switch (protection) {
+        case RW_USER:
+            l1pte->pte_1mb.ap = AP_RW;
+            break;
+        case RW_KER_ONLY:
+            l1pte->pte_1mb.ap = AP_KER_RW;
             break;
-        case PAGE_1MB:
-            l1pte->pte_1mb.tag = 0b10;
-            l1pte->pte_1mb.sec_base_addr = pa >> 20;
-            switch (protection) {
-            case RW_USER:
-                l1pte->pte_1mb.ap = AP_RW;
-                break;
-            case RW_KER_ONLY:
-                l1pte->pte_1mb.ap = AP_KER_RW;
-                break;
-            default:
-                panic("Bad protection!\n");
-            }
+        default:
+            panic("Bad protection!\n");
+        }
+        break;
+    case PAGE_4KB:
+        if (l1pte->pde.tag == 0b00) {
+            init_second_level(&l1pte->pde);
+        }
+        pte_small_t *l2pt =
+            (pte_small_t *) pa2ka((uintptr_t) l1pte->pde.addr << 10);
+        pte_small_t *l2pte = &l2pt[bits_get(va, 12, 19)];
+        l2pte->addr = pa >> 12;
+        switch (protection) {
+        case RW_USER:
+            l2pte->ap = AP_RW;
             break;
-        case PAGE_4KB:
-            if (l1pte->pde.tag == 0b00) {
-                init_second_level(&l1pte->pde);
-            }
-            pte_small_t* l2pt = (pte_small_t*) pa2ka((uintptr_t) l1pte->pde.addr << 10);
-            pte_small_t* l2pte = &l2pt[bits_get(va, 12, 19)];
-            l2pte->addr = pa >> 12;
-            switch (protection) {
-            case RW_USER:
-                l2pte->ap = AP_RW;
-                break;
-            case RW_KER_ONLY:
-                l2pte->ap = AP_KER_RW;
-                break;
-            default:
-                panic("Bad protection!\n");
-            }
-            l2pte->sz = 1;
+        case RW_KER_ONLY:
+            l2pte->ap = AP_KER_RW;
             break;
         default:
-            panic("invalid page type: %d\n", typ);
+            panic("Bad protection!\n");
+        }
+        l2pte->sz = 1;
+        break;
+    default:
+        panic("invalid page type: %d\n", typ);
     }
 }
 
-void vm_unmap(pagetable_t* pt, uintptr_t va) {
-    vm_map(pt, va, 0, PAGE_UNMAPPED, RW_USER); // TODO(masot)
+void vm_unmap(pagetable_t *pt, uintptr_t va) {
+    vm_map(pt, va, 0, PAGE_UNMAPPED, RW_USER);  // TODO(masot)
 }
 
-void vm_set_pt(pagetable_t* pt) {
+void vm_set_pt(pagetable_t *pt) {
     sys_set_tlb_base(ka2pa((uintptr_t) pt));
     sys_invalidate_tlb();
     sys_clean_and_invalidate_cache();
diff --git a/kern/vm.h b/kern/vm.h
index 0b3b8b7..0d65200 100644
--- a/kern/vm.h
+++ b/kern/vm.h
@@ -112,8 +112,12 @@ typedef enum {
     RW_KER_ONLY,
 } protection_typ_t;
 
-pagetable_t* kalloc_pt();
-void vm_map(pagetable_t* pt, uintptr_t va, uintptr_t pa, pg_typ_t typ, protection_typ_t protection);
-void vm_unmap(pagetable_t* pt, uintptr_t va);
-void vm_set_pt(pagetable_t* pt);
+pagetable_t *kalloc_pt();
+void vm_map(pagetable_t *pt,
+            uintptr_t va,
+            uintptr_t pa,
+            pg_typ_t typ,
+            protection_typ_t protection);
+void vm_unmap(pagetable_t *pt, uintptr_t va);
+void vm_set_pt(pagetable_t *pt);
 void vm_flushem();
diff --git a/libc/libc.c b/libc/libc.c
index cf7e3e4..c3b1f53 100644
--- a/libc/libc.c
+++ b/libc/libc.c
@@ -1,18 +1,18 @@
 #include <stddef.h>
 
-void* memchr(const void* s, int c, size_t n) {
-    const unsigned char* sp = s;
+void *memchr(const void *s, int c, size_t n) {
+    const unsigned char *sp = s;
 
     while (n--) {
         if (*sp == (unsigned char) c)
-            return (void*) sp;
+            return (void *) sp;
         sp++;
     }
 
     return NULL;
 }
 
-int memcmp(const void* s1, const void* s2, size_t n) {
+int memcmp(const void *s1, const void *s2, size_t n) {
     const unsigned char *c1 = s1, *c2 = s2;
     int d = 0;
 
@@ -25,9 +25,9 @@ int memcmp(const void* s1, const void* s2, size_t n) {
     return d;
 }
 
-void* memcpy(void* dst, const void* src, size_t n) {
-    const char* p = src;
-    char* q = dst;
+void *memcpy(void *dst, const void *src, size_t n) {
+    const char *p = src;
+    char *q = dst;
     while (n--) {
         *q++ = *p++;
     }
@@ -35,9 +35,9 @@ void* memcpy(void* dst, const void* src, size_t n) {
     return dst;
 }
 
-void* memmove(void* dst, const void* src, size_t count) {
-    char* a = dst;
-    const char* b = src;
+void *memmove(void *dst, const void *src, size_t count) {
+    char *a = dst;
+    const char *b = src;
 
     if (src == dst)
         return dst;
@@ -55,8 +55,8 @@ void* memmove(void* dst, const void* src, size_t count) {
     return dst;
 }
 
-void* memset(void* dst, int c, size_t n) {
-    char* q = dst;
+void *memset(void *dst, int c, size_t n) {
+    char *q = dst;
 
     while (n--) {
         *q++ = c;
@@ -65,9 +65,9 @@ void* memset(void* dst, int c, size_t n) {
     return dst;
 }
 
-void memswap(void* m1, void* m2, size_t n) {
-    char* p = m1;
-    char* q = m2;
+void memswap(void *m1, void *m2, size_t n) {
+    char *p = m1;
+    char *q = m2;
     char tmp;
 
     while (n--) {
@@ -90,7 +90,7 @@ static inline size_t newgap(size_t gap) {
     return gap;
 }
 
-int strcmp(const char* a, const char* b) {
+int strcmp(const char *a, const char *b) {
     while (1) {
         unsigned char ac = *a, bc = *b;
         if (ac == 0 || bc == 0 || ac != bc) {
@@ -100,7 +100,7 @@ int strcmp(const char* a, const char* b) {
     }
 }
 
-size_t strlen(const char* p) {
+size_t strlen(const char *p) {
     size_t ret;
     for (ret = 0; p[ret]; ++ret)
         ;
diff --git a/libc/tinyprintf.c b/libc/tinyprintf.c
index a7a528d..c169ac9 100644
--- a/libc/tinyprintf.c
+++ b/libc/tinyprintf.c
@@ -76,15 +76,15 @@ struct param {
     unsigned int width;  /**<  field width */
     char sign;           /**<  The sign to display (if any) */
     unsigned int base;   /**<  number base (e.g.: 8, 10, 16) */
-    char* bf;            /**<  Buffer to output */
+    char *bf;            /**<  Buffer to output */
 };
 
 #ifdef PRINTF_LONG_LONG_SUPPORT
 static void _TFP_GCC_NO_INLINE_ ulli2a(unsigned long long int num,
-                                       struct param* p) {
+                                       struct param *p) {
     int n = 0;
     unsigned long long int d = 1;
-    char* bf = p->bf;
+    char *bf = p->bf;
     while (num / d >= p->base)
         d *= p->base;
     while (d != 0) {
@@ -99,7 +99,7 @@ static void _TFP_GCC_NO_INLINE_ ulli2a(unsigned long long int num,
     *bf = 0;
 }
 
-static void lli2a(long long int num, struct param* p) {
+static void lli2a(long long int num, struct param *p) {
     if (num < 0) {
         num = -num;
         p->sign = '-';
@@ -109,10 +109,10 @@ static void lli2a(long long int num, struct param* p) {
 #endif
 
 #ifdef PRINTF_LONG_SUPPORT
-static void uli2a(unsigned long int num, struct param* p) {
+static void uli2a(unsigned long int num, struct param *p) {
     int n = 0;
     unsigned long int d = 1;
-    char* bf = p->bf;
+    char *bf = p->bf;
     while (num / d >= p->base)
         d *= p->base;
     while (d != 0) {
@@ -127,7 +127,7 @@ static void uli2a(unsigned long int num, struct param* p) {
     *bf = 0;
 }
 
-static void li2a(long num, struct param* p) {
+static void li2a(long num, struct param *p) {
     if (num < 0) {
         num = -num;
         p->sign = '-';
@@ -136,10 +136,10 @@ static void li2a(long num, struct param* p) {
 }
 #endif
 
-static void ui2a(unsigned int num, struct param* p) {
+static void ui2a(unsigned int num, struct param *p) {
     int n = 0;
     unsigned int d = 1;
-    char* bf = p->bf;
+    char *bf = p->bf;
     while (num / d >= p->base)
         d *= p->base;
     while (d != 0) {
@@ -154,7 +154,7 @@ static void ui2a(unsigned int num, struct param* p) {
     *bf = 0;
 }
 
-static void i2a(int num, struct param* p) {
+static void i2a(int num, struct param *p) {
     if (num < 0) {
         num = -num;
         p->sign = '-';
@@ -173,8 +173,8 @@ static int a2d(char ch) {
         return -1;
 }
 
-static char a2u(char ch, const char** src, int base, unsigned int* nump) {
-    const char* p = *src;
+static char a2u(char ch, const char **src, int base, unsigned int *nump) {
+    const char *p = *src;
     unsigned int num = 0;
     int digit;
     while ((digit = a2d(ch)) >= 0) {
@@ -188,10 +188,10 @@ static char a2u(char ch, const char** src, int base, unsigned int* nump) {
     return ch;
 }
 
-static void putchw(void* putp, putcf putf, struct param* p) {
+static void putchw(void *putp, putcf putf, struct param *p) {
     char ch;
     int n = p->width;
-    char* bf = p->bf;
+    char *bf = p->bf;
 
     /* Number of filling characters */
     while (*bf++ && n > 0)
@@ -239,7 +239,7 @@ static void putchw(void* putp, putcf putf, struct param* p) {
     }
 }
 
-void tfp_format(void* putp, putcf putf, const char* fmt, va_list va) {
+void tfp_format(void *putp, putcf putf, const char *fmt, va_list va) {
     struct param p;
 #ifdef PRINTF_LONG_SUPPORT
     char bf[23]; /* long = 64b on some architectures */
@@ -266,17 +266,17 @@ void tfp_format(void* putp, putcf putf, const char* fmt, va_list va) {
             /* Flags */
             while ((ch = *(fmt++))) {
                 switch (ch) {
-                    case '-':
-                        p.align_left = 1;
-                        continue;
-                    case '0':
-                        p.lz = 1;
-                        continue;
-                    case '#':
-                        p.alt = 1;
-                        continue;
-                    default:
-                        break;
+                case '-':
+                    p.align_left = 1;
+                    continue;
+                case '0':
+                    p.lz = 1;
+                    continue;
+                case '#':
+                    p.alt = 1;
+                    continue;
+                default:
+                    break;
                 }
                 break;
             }
@@ -324,84 +324,84 @@ void tfp_format(void* putp, putcf putf, const char* fmt, va_list va) {
             }
 #endif
             switch (ch) {
-                case 0:
-                    goto abort;
-                case 'u':
-                    p.base = 10;
+            case 0:
+                goto abort;
+            case 'u':
+                p.base = 10;
 #ifdef PRINTF_LONG_SUPPORT
 #ifdef PRINTF_LONG_LONG_SUPPORT
-                    if (2 == lng)
-                        ulli2a(va_arg(va, unsigned long long int), &p);
-                    else
+                if (2 == lng)
+                    ulli2a(va_arg(va, unsigned long long int), &p);
+                else
 #endif
-                        if (1 == lng)
-                        uli2a(va_arg(va, unsigned long int), &p);
-                    else
+                    if (1 == lng)
+                    uli2a(va_arg(va, unsigned long int), &p);
+                else
 #endif
-                        ui2a(va_arg(va, unsigned int), &p);
-                    putchw(putp, putf, &p);
-                    break;
-                case 'd':
-                case 'i':
-                    p.base = 10;
+                    ui2a(va_arg(va, unsigned int), &p);
+                putchw(putp, putf, &p);
+                break;
+            case 'd':
+            case 'i':
+                p.base = 10;
 #ifdef PRINTF_LONG_SUPPORT
 #ifdef PRINTF_LONG_LONG_SUPPORT
-                    if (2 == lng)
-                        lli2a(va_arg(va, long long int), &p);
-                    else
+                if (2 == lng)
+                    lli2a(va_arg(va, long long int), &p);
+                else
 #endif
-                        if (1 == lng)
-                        li2a(va_arg(va, long int), &p);
-                    else
+                    if (1 == lng)
+                    li2a(va_arg(va, long int), &p);
+                else
 #endif
-                        i2a(va_arg(va, int), &p);
-                    putchw(putp, putf, &p);
-                    break;
+                    i2a(va_arg(va, int), &p);
+                putchw(putp, putf, &p);
+                break;
 #ifdef SIZEOF_POINTER
-                case 'p':
-                    p.alt = 1;
+            case 'p':
+                p.alt = 1;
 #if defined(SIZEOF_INT) && SIZEOF_POINTER <= SIZEOF_INT
-                    lng = 0;
+                lng = 0;
 #elif defined(SIZEOF_LONG) && SIZEOF_POINTER <= SIZEOF_LONG
-                    lng = 1;
+                lng = 1;
 #elif defined(SIZEOF_LONG_LONG) && SIZEOF_POINTER <= SIZEOF_LONG_LONG
-                    lng = 2;
+                lng = 2;
 #endif
 #endif
-                case 'x':
-                case 'X':
-                    p.base = 16;
-                    p.uc = (ch == 'X') ? 1 : 0;
+            case 'x':
+            case 'X':
+                p.base = 16;
+                p.uc = (ch == 'X') ? 1 : 0;
 #ifdef PRINTF_LONG_SUPPORT
 #ifdef PRINTF_LONG_LONG_SUPPORT
-                    if (2 == lng)
-                        ulli2a(va_arg(va, unsigned long long int), &p);
-                    else
+                if (2 == lng)
+                    ulli2a(va_arg(va, unsigned long long int), &p);
+                else
 #endif
-                        if (1 == lng)
-                        uli2a(va_arg(va, unsigned long int), &p);
-                    else
+                    if (1 == lng)
+                    uli2a(va_arg(va, unsigned long int), &p);
+                else
 #endif
-                        ui2a(va_arg(va, unsigned int), &p);
-                    putchw(putp, putf, &p);
-                    break;
-                case 'o':
-                    p.base = 8;
                     ui2a(va_arg(va, unsigned int), &p);
-                    putchw(putp, putf, &p);
-                    break;
-                case 'c':
-                    putf(putp, (char) (va_arg(va, int)));
-                    break;
-                case 's':
-                    p.bf = va_arg(va, char*);
-                    putchw(putp, putf, &p);
-                    p.bf = bf;
-                    break;
-                case '%':
-                    putf(putp, ch);
-                default:
-                    break;
+                putchw(putp, putf, &p);
+                break;
+            case 'o':
+                p.base = 8;
+                ui2a(va_arg(va, unsigned int), &p);
+                putchw(putp, putf, &p);
+                break;
+            case 'c':
+                putf(putp, (char) (va_arg(va, int)));
+                break;
+            case 's':
+                p.bf = va_arg(va, char *);
+                putchw(putp, putf, &p);
+                p.bf = bf;
+                break;
+            case '%':
+                putf(putp, ch);
+            default:
+                break;
             }
         }
     }
@@ -410,14 +410,14 @@ abort:;
 
 #if TINYPRINTF_DEFINE_TFP_PRINTF
 static putcf stdout_putf;
-static void* stdout_putp;
+static void *stdout_putp;
 
-void init_printf(void* putp, putcf putf) {
+void init_printf(void *putp, putcf putf) {
     stdout_putf = putf;
     stdout_putp = putp;
 }
 
-void tfp_printf(char* fmt, ...) {
+void tfp_printf(char *fmt, ...) {
     va_list va;
     va_start(va, fmt);
     tfp_format(stdout_putp, stdout_putf, fmt, va);
@@ -428,18 +428,18 @@ void tfp_printf(char* fmt, ...) {
 #if TINYPRINTF_DEFINE_TFP_SPRINTF
 struct _vsnprintf_putcf_data {
     size_t dest_capacity;
-    char* dest;
+    char *dest;
     size_t num_chars;
 };
 
-static void _vsnprintf_putcf(void* p, char c) {
-    struct _vsnprintf_putcf_data* data = (struct _vsnprintf_putcf_data*) p;
+static void _vsnprintf_putcf(void *p, char c) {
+    struct _vsnprintf_putcf_data *data = (struct _vsnprintf_putcf_data *) p;
     if (data->num_chars < data->dest_capacity)
         data->dest[data->num_chars] = c;
     data->num_chars++;
 }
 
-int tfp_vsnprintf(char* str, size_t size, const char* format, va_list ap) {
+int tfp_vsnprintf(char *str, size_t size, const char *format, va_list ap) {
     struct _vsnprintf_putcf_data data;
 
     if (size < 1)
@@ -458,7 +458,7 @@ int tfp_vsnprintf(char* str, size_t size, const char* format, va_list ap) {
     return data.num_chars;
 }
 
-int tfp_snprintf(char* str, size_t size, const char* format, ...) {
+int tfp_snprintf(char *str, size_t size, const char *format, ...) {
     va_list ap;
     int retval;
 
@@ -469,16 +469,16 @@ int tfp_snprintf(char* str, size_t size, const char* format, ...) {
 }
 
 struct _vsprintf_putcf_data {
-    char* dest;
+    char *dest;
     size_t num_chars;
 };
 
-static void _vsprintf_putcf(void* p, char c) {
-    struct _vsprintf_putcf_data* data = (struct _vsprintf_putcf_data*) p;
+static void _vsprintf_putcf(void *p, char c) {
+    struct _vsprintf_putcf_data *data = (struct _vsprintf_putcf_data *) p;
     data->dest[data->num_chars++] = c;
 }
 
-int tfp_vsprintf(char* str, const char* format, va_list ap) {
+int tfp_vsprintf(char *str, const char *format, va_list ap) {
     struct _vsprintf_putcf_data data;
     data.dest = str;
     data.num_chars = 0;
@@ -487,7 +487,7 @@ int tfp_vsprintf(char* str, const char* format, va_list ap) {
     return data.num_chars;
 }
 
-int tfp_sprintf(char* str, const char* format, ...) {
+int tfp_sprintf(char *str, const char *format, ...) {
     va_list ap;
     int retval;
 
diff --git a/libc/tinyprintf.h b/libc/tinyprintf.h
index d61ea96..df3e7b7 100644
--- a/libc/tinyprintf.h
+++ b/libc/tinyprintf.h
@@ -142,7 +142,7 @@ regs Kusti, 23.10.2004
 extern "C" {
 #endif
 
-typedef void (*putcf)(void*, char);
+typedef void (*putcf)(void *, char);
 
 /*
    'tfp_format' really is the central function for all tinyprintf. For
@@ -154,14 +154,14 @@ typedef void (*putcf)(void*, char);
    The 'tfp_printf' and 'tfp_sprintf' functions simply define their own
    callback and pass to it the right 'putp' it is expecting.
 */
-void tfp_format(void* putp, putcf putf, const char* fmt, va_list va);
+void tfp_format(void *putp, putcf putf, const char *fmt, va_list va);
 
 #if TINYPRINTF_DEFINE_TFP_SPRINTF
-int tfp_vsnprintf(char* str, size_t size, const char* fmt, va_list ap);
-int tfp_snprintf(char* str, size_t size, const char* fmt, ...)
+int tfp_vsnprintf(char *str, size_t size, const char *fmt, va_list ap);
+int tfp_snprintf(char *str, size_t size, const char *fmt, ...)
     _TFP_SPECIFY_PRINTF_FMT(3, 4);
-int tfp_vsprintf(char* str, const char* fmt, va_list ap);
-int tfp_sprintf(char* str, const char* fmt, ...) _TFP_SPECIFY_PRINTF_FMT(2, 3);
+int tfp_vsprintf(char *str, const char *fmt, va_list ap);
+int tfp_sprintf(char *str, const char *fmt, ...) _TFP_SPECIFY_PRINTF_FMT(2, 3);
 #if TINYPRINTF_OVERRIDE_LIBC
 #define vsnprintf tfp_vsnprintf
 #define snprintf  tfp_snprintf
@@ -171,8 +171,8 @@ int tfp_sprintf(char* str, const char* fmt, ...) _TFP_SPECIFY_PRINTF_FMT(2, 3);
 #endif
 
 #if TINYPRINTF_DEFINE_TFP_PRINTF
-void init_printf(void* putp, putcf putf);
-void tfp_printf(char* fmt, ...) _TFP_SPECIFY_PRINTF_FMT(1, 2);
+void init_printf(void *putp, putcf putf);
+void tfp_printf(char *fmt, ...) _TFP_SPECIFY_PRINTF_FMT(1, 2);
 #if TINYPRINTF_OVERRIDE_LIBC
 #define printf tfp_printf
 #endif