add clang format and run it

19 files changed, 572 insertions, 517 deletions

diff --git a/common/bits.c b/common/bits.c
index b9814f6..698c082 100644
--- a/common/bits.c
+++ b/common/bits.c
@@ -12,21 +12,19 @@ __weak uint16_t __bswap16(const uint16_t u)
 #undef __bswap32
 __weak uint32_t __bswap32(const uint32_t u)
 {
-	return (u & 0xff000000) >> 24 |
-		(u & 0x00ff0000) >> 8 |
-		(u & 0x0000ff00) << 8 |
-		(u & 0x000000ff) << 24;
+	return (u & 0xff000000) >> 24 | (u & 0x00ff0000) >> 8 |
+	       (u & 0x0000ff00) << 8 | (u & 0x000000ff) << 24;
 }
 
 #undef __bswap64
 __weak uint64_t __bswap64(const uint64_t u)
 {
-	return (u & 0xff00000000000000ULL) >> 56	|
-		(u & 0x00ff000000000000ULL) >> 40	|
-		(u & 0x0000ff0000000000ULL) >> 24	|
-		(u & 0x000000ff00000000ULL) >> 8	|
-		(u & 0x00000000ff000000ULL) << 8	|
-		(u & 0x0000000000ff0000ULL) << 24	|
-		(u & 0x000000000000ff00ULL) << 40	|
-		(u & 0x00000000000000ffULL) << 56;
+	return (u & 0xff00000000000000ULL) >> 56 |
+	       (u & 0x00ff000000000000ULL) >> 40 |
+	       (u & 0x0000ff0000000000ULL) >> 24 |
+	       (u & 0x000000ff00000000ULL) >> 8 |
+	       (u & 0x00000000ff000000ULL) << 8 |
+	       (u & 0x0000000000ff0000ULL) << 24 |
+	       (u & 0x000000000000ff00ULL) << 40 |
+	       (u & 0x00000000000000ffULL) << 56;
 }
diff --git a/common/debug.c b/common/debug.c
index 330a3ed..43c9ae5 100644
--- a/common/debug.c
+++ b/common/debug.c
@@ -11,7 +11,7 @@
 static struct dbg_info {
 	pm_t dbg_ptr;
 	enum serial_dev dev;
-} dbg_info = (struct dbg_info){0};
+} dbg_info = (struct dbg_info){ 0 };
 
 void init_dbg(const void *fdt)
 {
@@ -75,7 +75,8 @@ static void __putchar(char c)
 	if (!port)
 		return;
 
-	while(__serial_tx_empty() == 0);
+	while (__serial_tx_empty() == 0)
+		;
 
 	port->data = c;
 }
@@ -91,13 +92,14 @@ static enum serial_dev __serial_dev_enum(const char *dev_name)
 struct dbg_info dbg_from_fdt(const void *fdt)
 {
 	int chosen_offset = fdt_path_offset(fdt, "/chosen");
-	const char *stdout = fdt_getprop(fdt, chosen_offset, "stdout-path", NULL);
+	const char *stdout =
+		fdt_getprop(fdt, chosen_offset, "stdout-path", NULL);
 
 	int stdout_offset = fdt_path_offset(fdt, stdout);
 
 	/* get serial device type */
 	const char *dev_name = (const char *)fdt_getprop(fdt, stdout_offset,
-			"compatible", NULL);
+	                                                 "compatible", NULL);
 
 	enum serial_dev dev = __serial_dev_enum(dev_name);
 
@@ -107,38 +109,38 @@ struct dbg_info dbg_from_fdt(const void *fdt)
 
 	pm_t dbg_ptr = (pm_t)fdt_load_int_ptr(ci.addr_cells, reg_ptr);
 
-	return (struct dbg_info){dbg_ptr, dev};
+	return (struct dbg_info){ dbg_ptr, dev };
 }
 
 void setup_dbg(vm_t pt, enum serial_dev dev)
 {
 	switch (dev) {
-		case NS16550A:
-			port = (struct ns16550a *)pt;
-			break;
+	case NS16550A:
+		port = (struct ns16550a *)pt;
+		break;
 	}
 
 	/* in the future possibly configure the serial connection, though the
 	 * defaults (set by U-boot) seem to work alright */
 }
 
-#define LEFT_FLAG  (1 << 0)
-#define SIGN_FLAG  (1 << 1)
-#define HASH_FLAG  (1 << 2)
-#define ZERO_FLAG  (1 << 3)
-#define FMT_FLAG   (1 << 4)
-#define SPACE_FLAG (1 << 5)
-#define LONG_FLAG  (1 << 6)
-#define LLONG_FLAG (1 << 7)
-#define SHORT_FLAG (1 << 8)
-#define CHAR_FLAG  (1 << 9)
-#define PRECS_FLAG (1 << 11)
+#define LEFT_FLAG   (1 << 0)
+#define SIGN_FLAG   (1 << 1)
+#define HASH_FLAG   (1 << 2)
+#define ZERO_FLAG   (1 << 3)
+#define FMT_FLAG    (1 << 4)
+#define SPACE_FLAG  (1 << 5)
+#define LONG_FLAG   (1 << 6)
+#define LLONG_FLAG  (1 << 7)
+#define SHORT_FLAG  (1 << 8)
+#define CHAR_FLAG   (1 << 9)
+#define PRECS_FLAG  (1 << 11)
 #define UNSIGN_FLAG (1 << 12)
 #define WIDTH_FLAG  (1 << 13)
-#define PAD_FLAG (1 << 14)
+#define PAD_FLAG    (1 << 14)
 
-#define CONT 1
-#define STOP 0
+#define CONT        1
+#define STOP        0
 
 static bool __is_digit(char c)
 {
@@ -148,38 +150,35 @@ static bool __is_digit(char c)
 static int __atoi(const char *s)
 {
 	unsigned int i = 0;
-	while(__is_digit(*s)){
+	while (__is_digit(*s)) {
 		i = i * 10 + (unsigned int)(*(s++) - '0');
 	}
 
 	return i;
 }
 
-static size_t __integral_val(ssize_t value, size_t base, size_t flags, bool print)
+static size_t __integral_val(ssize_t value, size_t base, size_t flags,
+                             bool print)
 {
 	/* assume ascii numbers, which is why 'signed char' is probably fine */
 	size_t ret = 0;
 	signed char c = 0;
 
-#define handle_type(x)\
-	c = (x)value % (x)base;\
+#define handle_type(x)                                                         \
+	c = (x)value % (x)base;                                                \
 	value = (x)value / (x)base;
 
-	if(!__is_set(flags, UNSIGN_FLAG)){
+	if (!__is_set(flags, UNSIGN_FLAG)) {
 		/* signed values, only with i format */
-		if(__is_set(flags, LLONG_FLAG)){
+		if (__is_set(flags, LLONG_FLAG)) {
 			handle_type(signed long long);
-		}
-		else if(__is_set(flags, LONG_FLAG)){
+		} else if (__is_set(flags, LONG_FLAG)) {
 			handle_type(signed long);
-		}
-		else if(__is_set(flags, SHORT_FLAG)){
+		} else if (__is_set(flags, SHORT_FLAG)) {
 			handle_type(signed short);
-		}
-		else if(__is_set(flags, CHAR_FLAG)){
+		} else if (__is_set(flags, CHAR_FLAG)) {
 			handle_type(signed char);
-		}
-		else {
+		} else {
 			handle_type(signed int);
 		}
 
@@ -188,34 +187,30 @@ static size_t __integral_val(ssize_t value, size_t base, size_t flags, bool prin
 
 	} else {
 		/* unsigned values, everything else */
-		if(__is_set(flags, LLONG_FLAG)){
+		if (__is_set(flags, LLONG_FLAG)) {
 			handle_type(unsigned long long);
-		}
-		else if(__is_set(flags, LONG_FLAG)){
+		} else if (__is_set(flags, LONG_FLAG)) {
 			handle_type(unsigned long);
-		}
-		else if(__is_set(flags, SHORT_FLAG)){
+		} else if (__is_set(flags, SHORT_FLAG)) {
 			handle_type(unsigned short);
-		}
-		else if(__is_set(flags, CHAR_FLAG)){
+		} else if (__is_set(flags, CHAR_FLAG)) {
 			handle_type(unsigned char);
-		}
-		else {
+		} else {
 			handle_type(unsigned int);
 		}
 	}
 
 #undef handle_type
 
-	if(base == 16)
+	if (base == 16)
 		c += c > 9 ? 'a' - 10 : '0';
 	else
 		c += '0';
 
-	if(value != 0)
+	if (value != 0)
 		ret = __integral_val(value, base, flags, print);
 
-	if(print)
+	if (print)
 		__putchar(c);
 
 	return ret + 1;
@@ -232,16 +227,16 @@ static size_t __print_prefix(size_t base)
 
 	const char *prefix;
 
-	if(base == 16)
+	if (base == 16)
 		prefix = hex;
-	else if(base == 8)
+	else if (base == 8)
 		prefix = oct;
-	else if(base == 2)
+	else if (base == 2)
 		prefix = bin;
 	else
 		prefix = empty;
 
-	for(; *prefix ; ++i)
+	for (; *prefix; ++i)
 		__putchar(*prefix++);
 
 	return i;
@@ -250,7 +245,7 @@ static size_t __print_prefix(size_t base)
 static size_t __print_padding(size_t pad, char pad_char)
 {
 	size_t i = 0;
-	for(; i < pad; ++i){
+	for (; i < pad; ++i) {
 		__putchar(pad_char);
 	}
 
@@ -259,22 +254,21 @@ static size_t __print_padding(size_t pad, char pad_char)
 
 static size_t __print_sign(ssize_t value, size_t flags)
 {
-	if(__is_set(flags, LLONG_FLAG))
+	if (__is_set(flags, LLONG_FLAG))
 		value = (signed long long)value;
-	else if(__is_set(flags, LONG_FLAG))
+	else if (__is_set(flags, LONG_FLAG))
 		value = (signed long)value;
-	else if(__is_set(flags, SHORT_FLAG))
+	else if (__is_set(flags, SHORT_FLAG))
 		value = (signed short)value;
-	else if(__is_set(flags, CHAR_FLAG))
+	else if (__is_set(flags, CHAR_FLAG))
 		value = (signed char)value;
 	else
 		value = (signed int)value;
 
-	if(value < 0){
+	if (value < 0) {
 		__putchar('-');
 		return 1;
-	}
-	else if(flags & SIGN_FLAG) {
+	} else if (flags & SIGN_FLAG) {
 		__putchar('+');
 		return 1;
 	}
@@ -282,10 +276,10 @@ static size_t __print_sign(ssize_t value, size_t flags)
 	return 0;
 }
 
-static size_t __print_integral(ssize_t value, size_t base,
-		size_t flags, size_t width)
+static size_t __print_integral(ssize_t value, size_t base, size_t flags,
+                               size_t width)
 {
-#define __integral_len(a, b, c) __integral_val((a), (b), (c), false)
+#define __integral_len(a, b, c)   __integral_val((a), (b), (c), false)
 #define __integral_print(a, b, c) __integral_val((a), (b), (c), true)
 
 	size_t ret = 0;
@@ -294,30 +288,30 @@ static size_t __print_integral(ssize_t value, size_t base,
 
 	/* depending on which flags are set, the prefix, sign and right justify has to
 	 * be ordereder differently. */
-	if(__is_set(flags, ZERO_FLAG)){
-		if(!__is_set(flags, UNSIGN_FLAG))
+	if (__is_set(flags, ZERO_FLAG)) {
+		if (!__is_set(flags, UNSIGN_FLAG))
 			ret += __print_sign(value, flags);
 
-		if(__is_set(flags, HASH_FLAG))
+		if (__is_set(flags, HASH_FLAG))
 			ret += __print_prefix(base);
 
-		if(pad > 0 && !__is_set(flags, LEFT_FLAG))
+		if (pad > 0 && !__is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, '0');
 
-	} else if (__is_set(flags, SPACE_FLAG)){
-		if(pad > 0 && !__is_set(flags, LEFT_FLAG))
+	} else if (__is_set(flags, SPACE_FLAG)) {
+		if (pad > 0 && !__is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, ' ');
 
-		if(!__is_set(flags, UNSIGN_FLAG))
+		if (!__is_set(flags, UNSIGN_FLAG))
 			ret += __print_sign(value, flags);
 
-		if(__is_set(flags, HASH_FLAG))
+		if (__is_set(flags, HASH_FLAG))
 			ret += __print_prefix(base);
 	} else {
-		if(!__is_set(flags, UNSIGN_FLAG))
+		if (!__is_set(flags, UNSIGN_FLAG))
 			ret += __print_sign(value, flags);
 
-		if(__is_set(flags, HASH_FLAG))
+		if (__is_set(flags, HASH_FLAG))
 			ret += __print_prefix(base);
 	}
 
@@ -325,11 +319,11 @@ static size_t __print_integral(ssize_t value, size_t base,
 	ret += __integral_print(value, base, flags);
 
 	/* left-justify */
-	if(__is_set(flags, ZERO_FLAG)){
-		if(pad > 0 && __is_set(flags, LEFT_FLAG))
+	if (__is_set(flags, ZERO_FLAG)) {
+		if (pad > 0 && __is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, '0');
-	} else if(__is_set(flags, SPACE_FLAG)) {
-		if(pad > 0 && __is_set(flags, LEFT_FLAG))
+	} else if (__is_set(flags, SPACE_FLAG)) {
+		if (pad > 0 && __is_set(flags, LEFT_FLAG))
 			ret += __print_padding(pad, ' ');
 	}
 
@@ -352,16 +346,15 @@ void dbg(const char *fmt, ...)
 
 	size_t chars_written = 0;
 
-	while(*fmt){
-
-		if (*fmt != '%'){
+	while (*fmt) {
+		if (*fmt != '%') {
 			__putchar(*fmt++);
 			chars_written++;
 			continue;
 		}
 
 		fmt++;
-		if(*fmt == '%'){
+		if (*fmt == '%') {
 			/* literal percent sign */
 			__putchar('%');
 			chars_written++;
@@ -373,44 +366,57 @@ void dbg(const char *fmt, ...)
 		size_t flags = 0;
 		int a = STOP;
 		do {
-			switch(*fmt){
-				case ' ':
-					__set_bit(flags, SPACE_FLAG); fmt++; a = CONT;
-					break;
+			switch (*fmt) {
+			case ' ':
+				__set_bit(flags, SPACE_FLAG);
+				fmt++;
+				a = CONT;
+				break;
 
-				case '-':
-					__set_bit(flags, LEFT_FLAG); fmt++; a = CONT;
-					break;
+			case '-':
+				__set_bit(flags, LEFT_FLAG);
+				fmt++;
+				a = CONT;
+				break;
 
-				case '+':
-					__set_bit(flags, SIGN_FLAG); fmt++; a = CONT;
-					break;
+			case '+':
+				__set_bit(flags, SIGN_FLAG);
+				fmt++;
+				a = CONT;
+				break;
 
-				case '#':
-					__set_bit(flags, HASH_FLAG); fmt++; a = CONT;
-					break;
+			case '#':
+				__set_bit(flags, HASH_FLAG);
+				fmt++;
+				a = CONT;
+				break;
 
-				case '0': __set_bit(flags, ZERO_FLAG); fmt++; a = CONT;
-					  break;
+			case '0':
+				__set_bit(flags, ZERO_FLAG);
+				fmt++;
+				a = CONT;
+				break;
 
-				case '\'':
-					  __set_bit(flags, FMT_FLAG); fmt++; a = CONT;
-					  break;
+			case '\'':
+				__set_bit(flags, FMT_FLAG);
+				fmt++;
+				a = CONT;
+				break;
 
-				default:
-					  a = STOP;
-					  break;
+			default:
+				a = STOP;
+				break;
 			}
 		} while (a != STOP);
 
 		/* check width */
 		size_t width = 0;
-		if(__is_digit(*fmt)){
+		if (__is_digit(*fmt)) {
 			width = __atoi(fmt++);
 			__set_bit(flags, WIDTH_FLAG | PAD_FLAG | SPACE_FLAG);
 		} else if (*fmt == '*') {
 			int w = va_arg(vl, int);
-			if(w < 0) {
+			if (w < 0) {
 				width = -w;
 				__set_bit(flags, LEFT_FLAG);
 			} else {
@@ -422,63 +428,62 @@ void dbg(const char *fmt, ...)
 
 		/* check precision */
 		size_t precision = 0;
-		if(*fmt == '.'){
+		if (*fmt == '.') {
 			fmt++;
 			__set_bit(flags, PRECS_FLAG | PAD_FLAG | ZERO_FLAG);
-			if(__is_digit(*fmt)){
+			if (__is_digit(*fmt)) {
 				precision = __atoi(fmt++);
-			} else if(*fmt == '*'){
+			} else if (*fmt == '*') {
 				precision = va_arg(vl, int);
 				fmt++;
 			}
 		}
 
 		/* check length */
-		switch(*fmt){
-			case 'l':
+		switch (*fmt) {
+		case 'l':
+			fmt++;
+			if (*fmt == 'l') {
+				__set_bit(flags, LLONG_FLAG);
 				fmt++;
-				if (*fmt == 'l'){
-					__set_bit(flags, LLONG_FLAG);
-					fmt++;
-				} else {
-					__set_bit(flags, LONG_FLAG);
-				}
-				break;
+			} else {
+				__set_bit(flags, LONG_FLAG);
+			}
+			break;
 
-			case 'h':
+		case 'h':
+			fmt++;
+			if (*fmt == 'h') {
+				__set_bit(flags, CHAR_FLAG);
 				fmt++;
-				if(*fmt == 'h') {
-					__set_bit(flags, CHAR_FLAG);
-					fmt++;
-				}
-				else {
-					__set_bit(flags, SHORT_FLAG);
-				}
-				break;
+			} else {
+				__set_bit(flags, SHORT_FLAG);
+			}
+			break;
 
-			case 'j':
-				fmt++;
-				if(sizeof(intmax_t) == sizeof(long))
-					__set_bit(flags, LONG_FLAG);
-				else
-					__set_bit(flags, LLONG_FLAG);
-				break;
+		case 'j':
+			fmt++;
+			if (sizeof(intmax_t) == sizeof(long))
+				__set_bit(flags, LONG_FLAG);
+			else
+				__set_bit(flags, LLONG_FLAG);
+			break;
 
-			case 'z':
-				fmt++;
-				if(sizeof(size_t) == sizeof(long))
-					__set_bit(flags, LONG_FLAG);
-				else
-					__set_bit(flags, LLONG_FLAG);
-				break;
+		case 'z':
+			fmt++;
+			if (sizeof(size_t) == sizeof(long))
+				__set_bit(flags, LONG_FLAG);
+			else
+				__set_bit(flags, LLONG_FLAG);
+			break;
 
-			case 't':
-				fmt++;
-				if(sizeof(ptrdiff_t) == sizeof(long))
-					__set_bit(flags, LONG_FLAG);
-				else
-					__set_bit(flags, LLONG_FLAG);
-				break;
+		case 't':
+			fmt++;
+			if (sizeof(ptrdiff_t) == sizeof(long))
+				__set_bit(flags, LONG_FLAG);
+			else
+				__set_bit(flags, LLONG_FLAG);
+			break;
 		}
 
 		/* read actual specifier */
@@ -490,87 +495,95 @@ void dbg(const char *fmt, ...)
 		int *n = 0;
 		char c = 0;
 
-		switch(*fmt){
-			case 'd':
-			case 'i':
-			case 'u':
+		switch (*fmt) {
+		case 'd':
+		case 'i':
+		case 'u':
+		case 'x':
+		case 'X':
+		case 'o':
+		case 'b':
+			/* integer handling */
+			switch (*fmt) {
 			case 'x':
+				base = 16;
+				break;
 			case 'X':
+				base = 2;
+				break;
 			case 'o':
-			case 'b':
-				/* integer handling */
-				switch(*fmt){
-					case 'x': base = 16; break;
-					case 'X': base = 2; break;
-					case 'o': base = 8;  break;
-					default : base = 10; break;
-				}
+				base = 8;
+				break;
+			default:
+				base = 10;
+				break;
+			}
 
-				if(base == 10)
-					__clear_bit(flags, HASH_FLAG);
+			if (base == 10)
+				__clear_bit(flags, HASH_FLAG);
 
-				/* precision takes precedence */
-				if(__is_set(flags, PRECS_FLAG))
-					width = precision;
+			/* precision takes precedence */
+			if (__is_set(flags, PRECS_FLAG))
+				width = precision;
 
-				/* formatting doesn't apply to decimal integers
+			/* formatting doesn't apply to decimal integers
 				 * */
-				if(*fmt != 'i' && *fmt != 'd'){
-					__clear_bit(flags, SIGN_FLAG);
-					__set_bit(flags, UNSIGN_FLAG);
-				}
+			if (*fmt != 'i' && *fmt != 'd') {
+				__clear_bit(flags, SIGN_FLAG);
+				__set_bit(flags, UNSIGN_FLAG);
+			}
 
-				if(__is_set(flags, LLONG_FLAG))
-					value = va_arg(vl, long long);
-				else if(__is_set(flags, LONG_FLAG))
-					value = va_arg(vl, long);
-				else
-					value = va_arg(vl, int);
+			if (__is_set(flags, LLONG_FLAG))
+				value = va_arg(vl, long long);
+			else if (__is_set(flags, LONG_FLAG))
+				value = va_arg(vl, long);
+			else
+				value = va_arg(vl, int);
 
-				chars_written += __print_integral(value, base,
-						flags, width);
-				fmt++;
-				break;
+			chars_written +=
+				__print_integral(value, base, flags, width);
+			fmt++;
+			break;
 
-			case 'c':
-				c = va_arg(vl, int);
-				__putchar(c);
-				chars_written++;
-				fmt++;
-				break;
+		case 'c':
+			c = va_arg(vl, int);
+			__putchar(c);
+			chars_written++;
+			fmt++;
+			break;
 
-			case 's':
-				s = va_arg(vl, const char *);
+		case 's':
+			s = va_arg(vl, const char *);
 
-				if(__is_set(flags, PRECS_FLAG))
-					i = precision;
+			if (__is_set(flags, PRECS_FLAG))
+				i = precision;
 
-				for(; *s && i--;){
-					__putchar(*s++);
-					chars_written++;
-				}
-				fmt++;
-				break;
+			for (; *s && i--;) {
+				__putchar(*s++);
+				chars_written++;
+			}
+			fmt++;
+			break;
 
-			case 'p':
-				p = va_arg(vl, void *);
-				__set_bit(flags, UNSIGN_FLAG | HASH_FLAG);
+		case 'p':
+			p = va_arg(vl, void *);
+			__set_bit(flags, UNSIGN_FLAG | HASH_FLAG);
 
-				if(sizeof(void *) == sizeof(long))
-					__set_bit(flags, LONG_FLAG);
-				else
-					__set_bit(flags, LLONG_FLAG);
+			if (sizeof(void *) == sizeof(long))
+				__set_bit(flags, LONG_FLAG);
+			else
+				__set_bit(flags, LLONG_FLAG);
 
-				chars_written += __print_integral((ssize_t)p, 16,
-						flags, width);
-				fmt++;
-				break;
+			chars_written +=
+				__print_integral((ssize_t)p, 16, flags, width);
+			fmt++;
+			break;
 
-			case 'n':
-				n = va_arg(vl, int *);
-				*n = chars_written;
-				fmt++;
-				break;
+		case 'n':
+			n = va_arg(vl, int *);
+			*n = chars_written;
+			fmt++;
+			break;
 		}
 	}
 
diff --git a/common/dmem.c b/common/dmem.c
index 48bcefd..226b3f9 100644
--- a/common/dmem.c
+++ b/common/dmem.c
@@ -1,7 +1,7 @@
 #include <apos/dmem.h>
 
-static struct mem_region_root pre_ram = {0};
-static struct mem_region_root post_ram = {0};
+static struct mem_region_root pre_ram = { 0 };
+static struct mem_region_root post_ram = { 0 };
 pm_t __pre_base = 0;
 pm_t __pre_top = 0;
 pm_t __post_base = 0;
@@ -26,20 +26,23 @@ stat_t init_devmem(pm_t ram_base, pm_t ram_top)
 	return OK;
 }
 
-stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
+stat_t dev_alloc_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr,
+                         vmflags_t flags, enum mm_order order)
 {
 	map_vpage(b, *offset, vaddr, flags, order);
 	*offset += __o_size(order);
 	return OK;
 }
 
-stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
+stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr,
+                        vmflags_t flags, enum mm_order order)
 {
-	UNUSED(offset); UNUSED(flags);
+	UNUSED(offset);
+	UNUSED(flags);
 	pm_t paddr = 0;
 	enum mm_order v_order = 0;
 	stat_vpage(b, vaddr, &paddr, &v_order, 0);
-	if(order != v_order)
+	if (order != v_order)
 		return REGION_TRY_AGAIN;
 
 	unmap_vpage(b, vaddr);
@@ -49,16 +52,17 @@ stat_t dev_free_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t
 vm_t alloc_devmem(struct tcb *t, pm_t dev_start, size_t bytes, vmflags_t flags)
 {
 	vm_t region = 0;
-	if(dev_start < __pre_top)
+	if (dev_start < __pre_top)
 		region = alloc_region(&pre_ram, bytes, 0);
 
-	if(dev_start > __post_base)
+	if (dev_start > __post_base)
 		region = alloc_region(&post_ram, bytes, 0);
 
-	if(!region)
+	if (!region)
 		return 0;
 
-	return map_fill_region(t->b_r, &dev_alloc_wrapper, dev_start, region, bytes, flags);
+	return map_fill_region(t->b_r, &dev_alloc_wrapper, dev_start, region,
+	                       bytes, flags);
 }
 
 stat_t free_devmem(struct tcb *t, vm_t dev_start)
@@ -66,26 +70,27 @@ stat_t free_devmem(struct tcb *t, vm_t dev_start)
 	pm_t dev_paddr = 0;
 	stat_vpage(t->b_r, dev_start, &dev_paddr, 0, 0);
 
-	if(dev_paddr >= __pre_top && dev_paddr <= __post_base)
+	if (dev_paddr >= __pre_top && dev_paddr <= __post_base)
 		return ERR_ADDR;
 
 	struct mem_region *m = 0;
-	if(dev_paddr < __pre_top)
+	if (dev_paddr < __pre_top)
 		m = find_used_region(&pre_ram, dev_paddr);
 
-	if(dev_paddr > __post_base)
+	if (dev_paddr > __post_base)
 		m = find_used_region(&post_ram, dev_paddr);
 
-	if(!m)
+	if (!m)
 		return ERR_NF;
 
 	size_t region_size = __addr(m->end - m->start);
-	map_fill_region(t->b_r, &dev_free_wrapper, dev_paddr, dev_start, region_size, 0);
+	map_fill_region(t->b_r, &dev_free_wrapper, dev_paddr, dev_start,
+	                region_size, 0);
 
-	if(dev_paddr < __pre_top)
+	if (dev_paddr < __pre_top)
 		free_region(&pre_ram, dev_paddr);
 
-	if(dev_paddr > __post_base)
+	if (dev_paddr > __post_base)
 		free_region(&post_ram, dev_paddr);
 
 	return OK;
diff --git a/common/elf.c b/common/elf.c
index 9ce357d..ddf61c9 100644
--- a/common/elf.c
+++ b/common/elf.c
@@ -6,20 +6,21 @@
 static uint8_t __elf_to_uvflags(uint8_t elf_flags)
 {
 	uint8_t uvflags = VM_V | VM_U;
-	if(elf_flags & PF_X)
+	if (elf_flags & PF_X)
 		uvflags |= VM_X;
 
-	if(elf_flags & PF_W)
+	if (elf_flags & PF_W)
 		uvflags |= VM_W;
 
-	if(elf_flags & PF_R)
+	if (elf_flags & PF_R)
 		uvflags |= VM_R;
 
 	return uvflags;
 }
 
 /* useful bit of info: all segments are sorted in ascending order of p_vaddr */
-static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size_t phnum, size_t phsize)
+static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart,
+                       size_t phnum, size_t phsize)
 {
 	/* TODO: take alignment into consideration? */
 	/* TODO: take overlapping memory regions into account, probably mostly
@@ -29,21 +30,22 @@ static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size
 	 * filled with zeroes. */
 	/* TODO: in general, make this a low more clean. */
 	vm_t runner = phstart;
-	for(size_t i = 0; i < phnum; ++i, runner += phsize){
-		if(program_header_prop(ei_c, runner, p_type) != PT_LOAD)
+	for (size_t i = 0; i < phnum; ++i, runner += phsize) {
+		if (program_header_prop(ei_c, runner, p_type) != PT_LOAD)
 			continue;
 
 		vm_t va = program_header_prop(ei_c, runner, p_vaddr);
 		size_t vsz = program_header_prop(ei_c, runner, p_memsz);
 
 		vm_t start = alloc_fixed_region(&t->sp_r, va, vsz, &vsz);
-		if(!start)
-				return; /* out of memory or something */
+		if (!start)
+			return; /* out of memory or something */
 
 		uint8_t elf_flags = program_header_prop(ei_c, runner, p_flags);
 		uint8_t uvflags = __elf_to_uvflags(elf_flags);
 
-		map_allocd_region(t->b_r, start, vsz, VM_V | VM_X | VM_R | VM_W | VM_U);
+		map_allocd_region(t->b_r, start, vsz,
+		                  VM_V | VM_X | VM_R | VM_W | VM_U);
 
 		vm_t vo = bin + program_header_prop(ei_c, runner, p_offset);
 		vm_t vfz = program_header_prop(ei_c, runner, p_filesz);
@@ -60,7 +62,8 @@ static void __map_exec(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size
 	}
 }
 
-static vm_t __map_dyn(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size_t phnum, size_t phsize)
+static vm_t __map_dyn(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart,
+                      size_t phnum, size_t phsize)
 {
 	/* TODO: this path should only be taken when no PT_INTERP is defined, as
 	 * making sure ld is loaded should be done in userspace. Maybe a bit
@@ -70,7 +73,7 @@ static vm_t __map_dyn(struct tcb *t, vm_t bin, uint8_t ei_c, vm_t phstart, size_
 static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf)
 {
 	short e_type = elf_header_prop(ei_c, elf, e_type);
-	if(e_type != ET_DYN && e_type != ET_EXEC)
+	if (e_type != ET_DYN && e_type != ET_EXEC)
 		return 0;
 
 	vm_t phstart = ptradd(elf, elf_header_prop(ei_c, elf, e_phoff));
@@ -78,7 +81,7 @@ static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf)
 	size_t phsize = elf_header_prop(ei_c, elf, e_phentsize);
 
 	vm_t entry = elf_header_prop(ei_c, elf, e_entry);
-	if(e_type == ET_EXEC){
+	if (e_type == ET_EXEC) {
 		__map_exec(t, elf, ei_c, phstart, phnum, phsize);
 		return entry;
 	} else {
@@ -91,11 +94,11 @@ static vm_t __prepare_proc(struct tcb *t, uint8_t ei_c, vm_t elf)
 vm_t load_elf(struct tcb *t, vm_t b)
 {
 	struct elf_ident *i = (struct elf_ident *)b;
-	if(i->ei_magic != cpu_to_be32(EI_MAGIC))
+	if (i->ei_magic != cpu_to_be32(EI_MAGIC))
 		return 0;
 
-	if(i->ei_class != ELFCLASS32 && i->ei_class != ELFCLASS64)
-			return 0;
+	if (i->ei_class != ELFCLASS32 && i->ei_class != ELFCLASS64)
+		return 0;
 
 	/* more sanity checks? */
 	return __prepare_proc(t, i->ei_class, b);
diff --git a/common/fdt.c b/common/fdt.c
index 7cec3a4..56b9d04 100644
--- a/common/fdt.c
+++ b/common/fdt.c
@@ -2,21 +2,19 @@
 
 struct cell_info get_cellinfo(const void *fdt, const int offset)
 {
-	return (struct cell_info){
-		fdt_size_cells(fdt, offset),
-		fdt_address_cells(fdt, offset)
-	};
+	return (struct cell_info){ fdt_size_cells(fdt, offset),
+		                   fdt_address_cells(fdt, offset) };
 }
 
 /* how "reg" is interpreted depends on the parent node */
 struct cell_info get_reginfo(const void *fdt, const char *path)
 {
 	const char *i = strrchr(path, '/');
-	if(!i)
-		return (struct cell_info){0, 0};
+	if (!i)
+		return (struct cell_info){ 0, 0 };
 
 	size_t baselen = i - path;
-	if(i == 0)
+	if (i == 0)
 		/* root node */
 		baselen = 1;
 
diff --git a/common/initrd.c b/common/initrd.c
index 7b5fa6c..28ddaec 100644
--- a/common/initrd.c
+++ b/common/initrd.c
@@ -25,28 +25,30 @@ struct __packed cpio_header {
 
 static struct cpio_header *__next_entry(struct cpio_header *cp)
 {
-	size_t blen = align_up(sizeof(struct cpio_header) + convnum(cp->c_namesize, 8, 16), 4);
+	size_t blen = align_up(
+		sizeof(struct cpio_header) + convnum(cp->c_namesize, 8, 16), 4);
 	size_t tlen = align_up(convnum(cp->c_filesize, 8, 16), 4);
 
 	return (struct cpio_header *)(((char *)cp) + blen + tlen);
 }
 
-static struct cpio_header *__find_file(const char *c, const char* fname, size_t fname_len)
+static struct cpio_header *__find_file(const char *c, const char *fname,
+                                       size_t fname_len)
 {
 	struct cpio_header *cp = (struct cpio_header *)c;
-	for(; cp; cp = __next_entry(cp)){
+	for (; cp; cp = __next_entry(cp)) {
 		size_t namelen = convnum(cp->c_namesize, 8, 16);
-		if(namelen == 0)
+		if (namelen == 0)
 			return 0;
 
-		if(namelen < fname_len)
+		if (namelen < fname_len)
 			continue;
 
 		char *name = (char *)(cp + 1);
-		if(fname[0] != '/')
+		if (fname[0] != '/')
 			name += namelen - (fname_len + 1); /* match ending */
 
-		if(strncmp(name, fname, fname_len) == 0)
+		if (strncmp(name, fname, fname_len) == 0)
 			return cp;
 	}
 
@@ -59,7 +61,7 @@ pm_t get_initrdtop(const void *fdt)
 	struct cell_info ci = get_cellinfo(fdt, chosen_offset);
 
 	void *initrd_end_ptr = (void *)fdt_getprop(fdt, chosen_offset,
-			"linux,initrd-end", NULL);
+	                                           "linux,initrd-end", NULL);
 
 	/* fdt is only aware of physical memory pointers */
 	return (pm_t)__va(fdt_load_int_ptr(ci.addr_cells, initrd_end_ptr));
@@ -71,7 +73,7 @@ pm_t get_initrdbase(const void *fdt)
 	const struct cell_info ci = get_cellinfo(fdt, chosen_offset);
 
 	void *initrd_base_ptr = (void *)fdt_getprop(fdt, chosen_offset,
-			"linux,initrd-start", NULL);
+	                                            "linux,initrd-start", NULL);
 
 	return (pm_t)__va(fdt_load_int_ptr(ci.addr_cells, initrd_base_ptr));
 }
diff --git a/common/mem.c b/common/mem.c
index 7a7eff6..a824c26 100644
--- a/common/mem.c
+++ b/common/mem.c
@@ -16,9 +16,9 @@ void init_mem(size_t max_order, size_t bits[10], size_t page_shift)
 
 	__mm_shifts[0] = 0;
 	__mm_widths[0] = 1 << bits[0];
-	__mm_sizes[0]  = 1 << __mm_page_shift;
+	__mm_sizes[0] = 1 << __mm_page_shift;
 
-	for(size_t i = 1; i <= __mm_max_order; ++i){
+	for (size_t i = 1; i <= __mm_max_order; ++i) {
 		__mm_widths[i] = 1 << bits[i];
 		__mm_shifts[i] = __mm_shifts[i - 1] + bits[i - 1];
 		__mm_sizes[i] = 1UL << __mm_shifts[i] << __mm_page_shift;
diff --git a/common/mem_nodes.c b/common/mem_nodes.c
index 099d578..2ab6978 100644
--- a/common/mem_nodes.c
+++ b/common/mem_nodes.c
@@ -4,9 +4,7 @@
 #include <apos/string.h>
 #include <apos/mem_nodes.h>
 
-enum block_status {
-	FREE = 0, USED = 1
-};
+enum block_status { FREE = 0, USED = 1 };
 
 struct block_wrapper {
 	enum block_status status;
@@ -23,16 +21,16 @@ struct block_region {
 	struct block_region *prev;
 };
 
-#define MAX_BLOCKS \
-	((BASE_PAGE_SIZE - sizeof(struct block_region)) / sizeof(struct block_wrapper))
+#define MAX_BLOCKS                                                             \
+	((BASE_PAGE_SIZE - sizeof(struct block_region)) /                      \
+	 sizeof(struct block_wrapper))
 
-#define block_region(b) \
+#define block_region(b)                                                        \
 	((struct block_region *)((size_t)(b) & ~(BASE_PAGE_SIZE - 1)))
 
-#define block_container(b) \
-	container_of(b, struct block_wrapper, n)
+#define block_container(b) container_of(b, struct block_wrapper, n)
 
-#define region_to_array(r) \
+#define region_to_array(r)                                                     \
 	((struct block_wrapper *)((char *)(r) + sizeof(struct block_region)))
 
 static struct block_region *head = 0;
@@ -40,7 +38,8 @@ static struct block_region *av_head = 0;
 
 static struct block_region *__create_region()
 {
-	struct block_region *r = (struct block_region *)alloc_page(BASE_PAGE, 0);
+	struct block_region *r =
+		(struct block_region *)alloc_page(BASE_PAGE, 0);
 	memset(r, FREE, BASE_PAGE_SIZE);
 	return r;
 }
@@ -54,7 +53,7 @@ void init_mem_blocks()
 void destroy_mem_blocks()
 {
 	struct block_region *r = head;
-	while(r){
+	while (r) {
 		struct block_region *d = r;
 		r = r->prev;
 		free_page(MM_O0, (pm_t)d);
@@ -64,8 +63,8 @@ void destroy_mem_blocks()
 static struct mem_region *__find_free_block(struct block_region *h)
 {
 	struct block_wrapper *w = region_to_array(h);
-	for(size_t i = 0; i < MAX_BLOCKS; ++i){
-		if(w[i].status != FREE)
+	for (size_t i = 0; i < MAX_BLOCKS; ++i) {
+		if (w[i].status != FREE)
 			continue;
 
 		w[i].status = USED;
@@ -79,7 +78,7 @@ static void __pop_av_head()
 {
 	struct block_region *t = av_head;
 	av_head = av_head->av_next;
-	if(av_head)
+	if (av_head)
 		av_head->av_prev = 0;
 
 	t->av_next = 0;
@@ -88,7 +87,7 @@ static void __pop_av_head()
 
 struct mem_region *get_mem_node()
 {
-	if(!av_head){
+	if (!av_head) {
 		av_head = __create_region();
 
 		av_head->prev = head;
@@ -99,7 +98,7 @@ struct mem_region *get_mem_node()
 
 	struct mem_region *ret = __find_free_block(av_head);
 
-	if(++av_head->used_blocks == MAX_BLOCKS)
+	if (++av_head->used_blocks == MAX_BLOCKS)
 		__pop_av_head();
 
 	return ret;
@@ -109,7 +108,7 @@ static void __push_av_head(struct block_region *r)
 {
 	r->av_prev = 0;
 	r->av_next = av_head;
-	if(av_head)
+	if (av_head)
 		av_head->av_prev = r;
 
 	av_head = r;
@@ -120,26 +119,26 @@ static void __free_block(struct block_region *r)
 	struct block_region *av_n = r->av_next;
 	struct block_region *av_p = r->av_prev;
 
-	if(av_n)
+	if (av_n)
 		av_n->av_prev = av_p;
 
-	if(av_p)
+	if (av_p)
 		av_p->av_next = av_n;
 
-	if(r == av_head)
+	if (r == av_head)
 		__pop_av_head();
 
 	struct block_region *n = r->next;
 	struct block_region *p = r->prev;
 
-	if(n)
+	if (n)
 		n->prev = p;
 
-	if(p)
+	if (p)
 		p->next = n;
 
-	if(r == head){
-		if(head->prev){
+	if (r == head) {
+		if (head->prev) {
 			head->next = 0;
 			head = head->prev;
 		} else
@@ -156,11 +155,11 @@ void free_mem_node(struct mem_region *m)
 
 	struct block_region *r = block_region(w);
 
-	if(--r->used_blocks == 0){
+	if (--r->used_blocks == 0) {
 		__free_block(r);
 		return;
 	}
 
-	else if(!r->av_next && !r->av_prev)
+	else if (!r->av_next && !r->av_prev)
 		__push_av_head(r);
 }
diff --git a/common/mem_regions.c b/common/mem_regions.c
index 7b9b629..975b6b5 100644
--- a/common/mem_regions.c
+++ b/common/mem_regions.c
@@ -3,9 +3,9 @@
 #include <apos/pmem.h>
 #include <apos/mem.h>
 
-#define mark_region_used(r) ((r) = 1)
+#define mark_region_used(r)   ((r) = 1)
 #define mark_region_unused(r) ((r) = 0)
-#define region_used(r) (r)
+#define region_used(r)        (r)
 
 /* pretty major slowdown when we get to some really massive numbers, not
  * entirely sure why. Will need to check up on this at some point, have I
@@ -23,31 +23,32 @@
  * maybe not even anything with sp_trees but more a weakness of binary trees in
  * general?
  */
-static struct mem_region *__insert_free_region(struct mem_region_root *r, struct mem_region *m)
+static struct mem_region *__insert_free_region(struct mem_region_root *r,
+                                               struct mem_region *m)
 {
 	struct sp_node *n = sp_root(r->free_regions), *p = NULL;
 	size_t start = m->start;
 	size_t size = m->end - m->start;
 	enum sp_dir d = LEFT;
 
-	m->sp_n = (struct sp_node){0};
+	m->sp_n = (struct sp_node){ 0 };
 
-	while(n){
+	while (n) {
 		struct mem_region *t = mem_container(n);
 		size_t nsize = t->end - t->start;
 		p = n;
 
-		if(size < nsize){
+		if (size < nsize) {
 			n = sp_left(n);
 			d = LEFT;
 		}
 
-		else if(size > nsize) {
+		else if (size > nsize) {
 			n = sp_right(n);
 			d = RIGHT;
 		}
 
-		else if (start < t->start){
+		else if (start < t->start) {
 			n = sp_left(n);
 			d = LEFT;
 		}
@@ -58,7 +59,7 @@ static struct mem_region *__insert_free_region(struct mem_region_root *r, struct
 		}
 	}
 
-	if(sp_root(r->free_regions))
+	if (sp_root(r->free_regions))
 		sp_insert(&sp_root(r->free_regions), p, &m->sp_n, d);
 	else
 		sp_root(r->free_regions) = &m->sp_n;
@@ -66,20 +67,21 @@ static struct mem_region *__insert_free_region(struct mem_region_root *r, struct
 	return m;
 }
 
-static struct mem_region *__insert_used_region(struct mem_region_root *r, struct mem_region *m)
+static struct mem_region *__insert_used_region(struct mem_region_root *r,
+                                               struct mem_region *m)
 {
 	struct sp_node *n = sp_root(r->used_regions), *p = NULL;
 	vm_t start = m->start;
 	enum sp_dir d = LEFT;
 
-	m->sp_n = (struct sp_node){0};
+	m->sp_n = (struct sp_node){ 0 };
 
-	while(n){
+	while (n) {
 		struct mem_region *t = mem_container(n);
 
 		p = n;
 
-		if(start < t->start){
+		if (start < t->start) {
 			n = sp_left(n);
 			d = LEFT;
 		}
@@ -92,7 +94,7 @@ static struct mem_region *__insert_used_region(struct mem_region_root *r, struct
 		}
 	}
 
-	if(sp_root(r->used_regions))
+	if (sp_root(r->used_regions))
 		sp_insert(&sp_root(r->used_regions), p, &m->sp_n, d);
 	else
 		sp_root(r->used_regions) = &m->sp_n;
@@ -115,7 +117,7 @@ stat_t init_region(struct mem_region_root *r, vm_t start, size_t arena_size)
 
 static void __destroy_region(struct sp_node *n)
 {
-	if(!n)
+	if (!n)
 		return;
 
 	__destroy_region(sp_left(n));
@@ -139,12 +141,12 @@ void destroy_region(struct mem_region_root *r)
 struct mem_region *find_used_region(struct mem_region_root *r, vm_t start)
 {
 	struct sp_node *n = sp_root(r->used_regions);
-	while(n){
+	while (n) {
 		struct mem_region *t = mem_container(n);
-		if(start == t->start)
+		if (start == t->start)
 			return t;
 
-		if(start < t->start)
+		if (start < t->start)
 			n = sp_left(n);
 		else
 			n = sp_right(n);
@@ -154,7 +156,8 @@ struct mem_region *find_used_region(struct mem_region_root *r, vm_t start)
 }
 
 static struct mem_region *create_region(vm_t start, vm_t end,
-		struct mem_region *prev, struct mem_region *next)
+                                        struct mem_region *prev,
+                                        struct mem_region *next)
 {
 	struct mem_region *m = get_mem_node();
 	m->start = start;
@@ -168,35 +171,36 @@ static struct mem_region *create_region(vm_t start, vm_t end,
  * just from really quick checking */
 static size_t po_align(size_t s)
 {
-	for(size_t o = __mm_max_order; o > 0; --o){
-		if(s >= __o_size(o))
+	for (size_t o = __mm_max_order; o > 0; --o) {
+		if (s >= __o_size(o))
 			return __o_size(o);
 	}
 
 	return 0;
 }
 
-struct mem_region *find_closest_used_region(struct mem_region_root *r, vm_t start)
+struct mem_region *find_closest_used_region(struct mem_region_root *r,
+                                            vm_t start)
 {
 	struct mem_region *closest = 0;
 	size_t md = (size_t)(-1);
 	struct sp_node *n = sp_root(r->used_regions);
-	if(!n)
+	if (!n)
 		return mem_container(sp_root(r->free_regions));
 
-	while(n){
+	while (n) {
 		struct mem_region *t = mem_container(n);
 		size_t d = ABS((ssize_t)start - (ssize_t)t->start);
 
-		if(d == 0) /* exact match */
+		if (d == 0) /* exact match */
 			return t;
 
-		if(d < md){ /* closest so far */
+		if (d < md) { /* closest so far */
 			closest = t;
 			md = d;
 		}
 
-		if(start < t->start)
+		if (start < t->start)
 			n = sp_left(n);
 		else
 			n = sp_right(n);
@@ -212,23 +216,24 @@ struct mem_region *find_closest_used_region(struct mem_region_root *r, vm_t star
  * still fits in, unaligned. If none of these criteria are met, a NULL is
  * returned. Note that this does not check *all* possible memory blocks, only
  * going up in increasing size so as to save time. */
-struct mem_region *find_free_region(struct mem_region_root *r, size_t size, size_t *align)
+struct mem_region *find_free_region(struct mem_region_root *r, size_t size,
+                                    size_t *align)
 {
 	*align = 0;
 	size_t offset = __page(po_align(__addr(size)));
 	struct mem_region *quick_best = 0;
 	struct sp_node *n = sp_root(r->free_regions);
-	while(n){
+	while (n) {
 		struct mem_region *t = mem_container(n);
 		vm_t start = align_up(t->start, offset);
 
 		size_t qsize = t->end - t->start;
 		size_t bsize = t->end - start;
 
-		if(!quick_best && size <= qsize)
+		if (!quick_best && size <= qsize)
 			quick_best = t;
 
-		if(size <= bsize){
+		if (size <= bsize) {
 			*align = start - t->start;
 			return t;
 		}
@@ -240,32 +245,34 @@ struct mem_region *find_free_region(struct mem_region_root *r, size_t size, size
 }
 
 static vm_t __partition_region(struct mem_region_root *r, struct mem_region *m,
-		size_t pages, size_t align)
+                               size_t pages, size_t align)
 {
 	sp_remove(&sp_root(r->free_regions), &m->sp_n);
 
 	vm_t pre_start = m->start;
 	vm_t pre_end = pre_start + align;
-	
+
 	vm_t start = pre_end;
 	vm_t end = start + pages;
 
 	vm_t post_start = end;
 	vm_t post_end = m->end;
 
-	if(pre_start != pre_end){
-		struct mem_region *n = create_region(pre_start, pre_end, m->prev, m);
+	if (pre_start != pre_end) {
+		struct mem_region *n =
+			create_region(pre_start, pre_end, m->prev, m);
 		m->prev = n;
-		if(n->prev)
+		if (n->prev)
 			n->prev->next = n;
 
 		__insert_free_region(r, n);
 	}
 
-	if(post_start != post_end){
-		struct mem_region *n = create_region(post_start, post_end, m, m->next);
+	if (post_start != post_end) {
+		struct mem_region *n =
+			create_region(post_start, post_end, m, m->next);
 		m->next = n;
-		if(n->next)
+		if (n->next)
 			n->next->prev = n;
 
 		__insert_free_region(r, n);
@@ -282,8 +289,7 @@ static vm_t __partition_region(struct mem_region_root *r, struct mem_region *m,
  * just ignore them for now. Note that alloc_region should only be used when
  * mmap is called with MAP_ANON, all other situations should be handled in some
  * fs server */
-vm_t alloc_region(struct mem_region_root *r,
-		size_t size, size_t *actual_size)
+vm_t alloc_region(struct mem_region_root *r, size_t size, size_t *actual_size)
 {
 	*actual_size = align_up(size, BASE_PAGE_SIZE);
 	size_t pages = __page(*actual_size);
@@ -291,41 +297,40 @@ vm_t alloc_region(struct mem_region_root *r,
 	/* find best fitting, alignment etc. */
 	size_t align = 0;
 	struct mem_region *m = find_free_region(r, pages, &align);
-	if(!m)
+	if (!m)
 		return 0;
 
 	return __partition_region(r, m, pages, align);
 }
 
-
-vm_t alloc_fixed_region(struct mem_region_root *r,
-		vm_t start, size_t size, size_t *actual_size)
+vm_t alloc_fixed_region(struct mem_region_root *r, vm_t start, size_t size,
+                        size_t *actual_size)
 {
 	size_t asize = align_up(size, BASE_PAGE_SIZE);
-	if(actual_size)
+	if (actual_size)
 		*actual_size = asize;
 
 	size_t pages = __page(asize);
 	start = __page(start);
 
 	struct mem_region *m = find_closest_used_region(r, start);
-	if(!m)
+	if (!m)
 		return 0;
 
 	/* locate actual region where start is between the region start and end */
-	while(!((m->start <= start) && (start <= m->end))){
-		if(start > m->start)
+	while (!((m->start <= start) && (start <= m->end))) {
+		if (start > m->start)
 			m = m->next;
 		else
 			m = m->prev;
 	}
 
 	/* if region is already in use, forget it */
-	if(region_used(m->flags))
+	if (region_used(m->flags))
 		return 0;
 
 	/* region is too small */
-	if(start + pages > m->end)
+	if (start + pages > m->end)
 		return 0;
 
 	/* actually start marking region used */
@@ -334,18 +339,18 @@ vm_t alloc_fixed_region(struct mem_region_root *r,
 
 static void __try_coalesce_prev(struct mem_region_root *r, struct mem_region *m)
 {
-	while(m){
-		if(!m || region_used(m->flags))
+	while (m) {
+		if (!m || region_used(m->flags))
 			return;
 
 		struct mem_region *p = m->prev;
-		if(!p || region_used(p->flags))
+		if (!p || region_used(p->flags))
 			return;
 
 		m->start = p->start;
 		m->prev = p->prev;
 
-		if(m->prev)
+		if (m->prev)
 			m->prev->next = m;
 
 		sp_remove(&sp_root(r->free_regions), &p->sp_n);
@@ -357,18 +362,18 @@ static void __try_coalesce_prev(struct mem_region_root *r, struct mem_region *m)
 
 static void __try_coalesce_next(struct mem_region_root *r, struct mem_region *m)
 {
-	while(m){
-		if(!m || region_used(m->flags))
+	while (m) {
+		if (!m || region_used(m->flags))
 			return;
 
 		struct mem_region *n = m->next;
-		if(!n || region_used(n->flags))
+		if (!n || region_used(n->flags))
 			return;
 
 		m->end = n->end;
 		m->next = n->next;
 
-		if(m->next)
+		if (m->next)
 			m->next->prev = m;
 
 		sp_remove(&sp_root(r->free_regions), &n->sp_n);
@@ -378,7 +383,8 @@ static void __try_coalesce_next(struct mem_region_root *r, struct mem_region *m)
 	}
 }
 
-static void __try_coalesce_regions(struct mem_region_root *r, struct mem_region *m)
+static void __try_coalesce_regions(struct mem_region_root *r,
+                                   struct mem_region *m)
 {
 	__try_coalesce_prev(r, m);
 	__try_coalesce_next(r, m);
@@ -387,11 +393,11 @@ static void __try_coalesce_regions(struct mem_region_root *r, struct mem_region
 stat_t free_region(struct mem_region_root *r, vm_t start)
 {
 	/* addr not aligned to page boundary, corrupted or incorrect pointer */
-	if(!aligned(start, BASE_PAGE_SIZE))
+	if (!aligned(start, BASE_PAGE_SIZE))
 		return ERR_ALIGN;
 
 	struct mem_region *m = find_used_region(r, __page(start));
-	if(!m)
+	if (!m)
 		return ERR_NF;
 
 	sp_remove(&sp_root(r->used_regions), &m->sp_n);
@@ -409,7 +415,7 @@ stat_t free_region(struct mem_region_root *r, vm_t start)
  * permutations etc. which would be slow and I don't want to implement it.
  */
 vm_t map_fill_region(struct vm_branch *b, region_callback_t *mem_handler,
-		pm_t offset, vm_t start, size_t bytes, vmflags_t flags)
+                     pm_t offset, vm_t start, size_t bytes, vmflags_t flags)
 {
 	pm_t runner = __page(start);
 	size_t pages = __pages(bytes);
@@ -418,22 +424,23 @@ vm_t map_fill_region(struct vm_branch *b, region_callback_t *mem_handler,
 	/* actual start might not be the same as the user specified start */
 	start = __addr(runner);
 
-	for(; pages; top--){
+	for (; pages; top--) {
 		size_t o_size = __o_size(top);
 		size_t o_pages = __pages(o_size);
 
 		/* NULL does pass this check, so technically all NULL pages are
 		 * aligned, but they're caught in the while expr so this should
 		 * work even if someone tries to map NULL */
-		if(!aligned(runner, o_pages))
+		if (!aligned(runner, o_pages))
 			continue;
 
-		while(pages >= o_pages){
-			stat_t res = mem_handler(b, &offset, __addr(runner), flags, top);
-			if(res > 0)
+		while (pages >= o_pages) {
+			stat_t res = mem_handler(b, &offset, __addr(runner),
+			                         flags, top);
+			if (res > 0)
 				break;
 
-			if(res < 0)
+			if (res < 0)
 				return 0;
 
 			pages -= o_pages;
diff --git a/common/pmem.c b/common/pmem.c
index 4c965cf..6ef89bc 100644
--- a/common/pmem.c
+++ b/common/pmem.c
@@ -8,25 +8,28 @@
 #include <libfdt.h>
 
 /* NOTE: these are all for pnum_t, i.e. O0_SHIFT is from 0 */
-#define __foreach_page(var, start, end, attr, neg)\
-	for(size_t i = num_indexes(start); i < num_elems(end); ++i)\
-	if(var->attr[i] == (mm_info_t)(-1)) continue;\
-	else for(pnum_t page = i * MM_OINFO_WIDTH, j = 0;\
-			j < (pnum_t)MIN((end) - i * MM_OINFO_WIDTH, MM_OINFO_WIDTH);\
-			++j, ++page)\
-		if(neg(__is_nset(var->attr[i], j)))
+#define __foreach_page(var, start, end, attr, neg)                             \
+	for (size_t i = num_indexes(start); i < num_elems(end); ++i)           \
+		if (var->attr[i] == (mm_info_t)(-1))                           \
+			continue;                                              \
+		else                                                           \
+			for (pnum_t page = i * MM_OINFO_WIDTH, j = 0;          \
+			     j < (pnum_t)MIN((end)-i * MM_OINFO_WIDTH,         \
+			                     MM_OINFO_WIDTH);                  \
+			     ++j, ++page)                                      \
+				if (neg(__is_nset(var->attr[i], j)))
 
 #define NEG !
-#define foreach_full_page(var, start, order)\
+#define foreach_full_page(var, start, order)                                   \
 	__foreach_page(var, start, var->entries, full, )
 
-#define foreach_not_full_page(var, start, order)\
+#define foreach_not_full_page(var, start, order)                               \
 	__foreach_page(var, start, var->entries, full, NEG)
 
-#define foreach_used_page(var, start, order)\
+#define foreach_used_page(var, start, order)                                   \
 	__foreach_page(var, start, var->entries, used, )
 
-#define foreach_not_used_page(var, start, order)\
+#define foreach_not_used_page(var, start, order)                               \
 	__foreach_page(var, start, var->entries, used, NEG)
 
 typedef uint32_t mm_info_t;
@@ -55,8 +58,8 @@ struct mm_pmap_t {
 
 static struct mm_pmap_t *pmap = 0;
 
-static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order tgt,
-	enum mm_order src, enum mm_order dst)
+static void __mark_free(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
+                        enum mm_order src, enum mm_order dst)
 {
 	size_t idx = pnum_to_index(pnum, src);
 
@@ -67,7 +70,7 @@ static void __mark_free(mm_node_t * op, pnum_t pnum, enum mm_order tgt,
 	}
 
 	struct mm_branch_t *o = (struct mm_branch_t *)op;
-	if(src != tgt)
+	if (src != tgt)
 		__mark_free(o->next[idx], pnum, tgt, src - 1, dst);
 
 	/* freeing a page results in always clearing a full bit? */
@@ -87,15 +90,15 @@ void free_page(enum mm_order order, pm_t paddr)
 
 		for (size_t j = 0; j < omap->order; ++j)
 			__mark_free(omap->orders[j],
-				pm_to_pnum(paddr - omap->base),
-				order, omap->order, j);
+			            pm_to_pnum(paddr - omap->base), order,
+			            omap->order, j);
 
 		return;
 	}
 }
 
-static bool __mark_used(mm_node_t * op, pnum_t pnum, enum mm_order tgt,
-	enum mm_order src, enum mm_order dst)
+static bool __mark_used(mm_node_t *op, pnum_t pnum, enum mm_order tgt,
+                        enum mm_order src, enum mm_order dst)
 {
 	size_t idx = pnum_to_index(pnum, src);
 
@@ -141,21 +144,22 @@ void mark_used(enum mm_order order, pm_t paddr)
 
 		for (size_t j = 0; j <= omap->order; ++j)
 			__mark_used(omap->orders[j],
-				pm_to_pnum(paddr - omap->base),
-				order, omap->order, j);
+			            pm_to_pnum(paddr - omap->base), order,
+			            omap->order, j);
 
 		return;
 	}
 }
 
-static pnum_t __enum_order(mm_node_t * op, pnum_t offset,
-	enum mm_order src, enum mm_order dst)
+static pnum_t __enum_order(mm_node_t *op, pnum_t offset, enum mm_order src,
+                           enum mm_order dst)
 {
 	size_t idx = pnum_to_index(offset, src);
 
 	if (src == dst) {
 		struct mm_leaf_t *o = (struct mm_leaf_t *)op;
-		foreach_not_used_page(o, idx, src) {
+		foreach_not_used_page(o, idx, src)
+		{
 			return page << __o_offset(src);
 		}
 
@@ -163,11 +167,12 @@ static pnum_t __enum_order(mm_node_t * op, pnum_t offset,
 	}
 
 	struct mm_branch_t *o = (struct mm_branch_t *)op;
-	foreach_not_full_page(o, idx, src) {
+	foreach_not_full_page(o, idx, src)
+	{
 		/* if the suggested search index is full, the following level
 		 * would get an incorrect offset if trying to follow the original
 		 * suggestion. */
-		if (page != (pnum_t) idx)
+		if (page != (pnum_t)idx)
 			offset = 0;
 
 		pnum_t ret = __enum_order(o->next[page], offset, src - 1, dst);
@@ -195,8 +200,8 @@ pm_t alloc_page(enum mm_order order, pm_t offset)
 		if (offset != 0)
 			base = offset - omap->base;
 
-		pnum = __enum_order(omap->orders[order],
-			pm_to_pnum(base), omap->order, order);
+		pnum = __enum_order(omap->orders[order], pm_to_pnum(base),
+		                    omap->order, order);
 
 		if (!(pnum < 0))
 			break;
@@ -211,43 +216,43 @@ pm_t alloc_page(enum mm_order order, pm_t offset)
 }
 
 /* unfortunate that populating the mm info is so complicated */
-static pm_t __populate_order(mm_node_t ** op, pm_t cont,
-	enum mm_order src, enum mm_order dst, size_t num)
+static pm_t __populate_order(mm_node_t **op, pm_t cont, enum mm_order src,
+                             enum mm_order dst, size_t num)
 {
 	if (src == dst) {
-		struct mm_leaf_t *o = (struct mm_leaf_t *)
-			move_forward(cont, sizeof(struct mm_leaf_t));
+		struct mm_leaf_t *o = (struct mm_leaf_t *)move_forward(
+			cont, sizeof(struct mm_leaf_t));
 
 		o->entries = num;
-		o->used = (mm_info_t *) move_forward(cont, state_elems(num));
+		o->used = (mm_info_t *)move_forward(cont, state_elems(num));
 		memset(o->used, 0, state_elems(num));
 
-		*op = (mm_node_t *) o;
+		*op = (mm_node_t *)o;
 		return cont;
 	}
 
-	struct mm_branch_t *o = (struct mm_branch_t *)
-		move_forward(cont, sizeof(struct mm_branch_t));
+	struct mm_branch_t *o = (struct mm_branch_t *)move_forward(
+		cont, sizeof(struct mm_branch_t));
 
 	o->entries = num;
-	o->full = (mm_info_t *) move_forward(cont, state_elems(num));
-	o->next = (mm_node_t **) move_forward(cont, next_elems(num));
+	o->full = (mm_info_t *)move_forward(cont, state_elems(num));
+	o->next = (mm_node_t **)move_forward(cont, next_elems(num));
 	memset(o->full, 0, state_elems(num));
 	memset(o->next, 0, next_elems(num));
 
 	for (size_t i = 0; i < num; ++i) {
-		cont = __populate_order(&o->next[i], cont,
-			src - 1, dst, __o_width(src - 1));
+		cont = __populate_order(&o->next[i], cont, src - 1, dst,
+		                        __o_width(src - 1));
 	}
 
-	*op = (mm_node_t *) o;
+	*op = (mm_node_t *)o;
 	return cont;
 }
 
 static pm_t __probe_order(pm_t cont, enum mm_order src, enum mm_order dst,
-		size_t num)
+                          size_t num)
 {
-	if(src == dst){
+	if (src == dst) {
 		cont += sizeof(struct mm_leaf_t);
 		cont += state_elems(num);
 		return cont;
@@ -257,29 +262,29 @@ static pm_t __probe_order(pm_t cont, enum mm_order src, enum mm_order dst,
 	cont += state_elems(num);
 	cont += next_elems(num);
 
-	for(size_t i = 0; i < num; ++i)
+	for (size_t i = 0; i < num; ++i)
 		cont = __probe_order(cont, src - 1, dst, __o_width(src - 1));
 
 	return cont;
 }
 
-static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont,
-	pm_t base, size_t entries, enum mm_order order)
+static pm_t __populate_omap(struct mm_omap_t **omap, pm_t cont, pm_t base,
+                            size_t entries, enum mm_order order)
 {
-	struct mm_omap_t *lomap = (struct mm_omap_t *)
-		move_forward(cont, sizeof(struct mm_omap_t));
+	struct mm_omap_t *lomap = (struct mm_omap_t *)move_forward(
+		cont, sizeof(struct mm_omap_t));
 	memset(lomap, 0, sizeof(struct mm_omap_t));
 
-	lomap->orders = (mm_node_t **) move_forward(cont,
-		(order + 1) * sizeof(mm_node_t **));
+	lomap->orders = (mm_node_t **)move_forward(
+		cont, (order + 1) * sizeof(mm_node_t **));
 	memset(lomap->orders, 0, (order + 1) * sizeof(mm_node_t **));
 
 	lomap->order = order;
 	lomap->base = base;
 
 	for (size_t i = 0; i <= order; ++i)
-		cont = __populate_order(&lomap->orders[i], cont,
-			order, i, entries);
+		cont = __populate_order(&lomap->orders[i], cont, order, i,
+		                        entries);
 
 	*omap = lomap;
 	return cont;
@@ -290,7 +295,7 @@ static pm_t __probe_omap(pm_t cont, size_t entries, enum mm_order order)
 	cont += sizeof(struct mm_omap_t);
 	cont += (order + 1) * sizeof(mm_node_t **);
 
-	for(size_t i = 0; i <= order; ++i)
+	for (size_t i = 0; i <= order; ++i)
 		cont = __probe_order(cont, order, i, entries);
 
 	return cont;
@@ -310,8 +315,8 @@ pm_t populate_pmap(pm_t ram_base, size_t ram_size, pm_t cont)
 		if (entries == 0)
 			continue;
 
-		cont = __populate_omap(&pmap->omap[i], cont,
-			ram_region, entries, i);
+		cont = __populate_omap(&pmap->omap[i], cont, ram_region,
+		                       entries, i);
 
 		ram_left -= __mm_sizes[i] * entries;
 		ram_region += (__mm_sizes[i] * entries);
@@ -332,9 +337,9 @@ pm_t probe_pmap(pm_t ram_base, size_t ram_size)
 
 	pm_t ram_region = ram_base;
 	size_t ram_left = ram_size;
-	for(ssize_t i = __mm_max_order; i >= MM_O0; --i){
+	for (ssize_t i = __mm_max_order; i >= MM_O0; --i) {
 		size_t entries = ram_left / __mm_sizes[i];
-		if(entries == 0)
+		if (entries == 0)
 			continue;
 
 		cont = __probe_omap(cont, entries, i);
@@ -350,13 +355,13 @@ static void __mark_area_used(pm_t base, pm_t top)
 {
 	size_t area_left = top - base;
 	pm_t runner = base;
-	while(area_left >= BASE_PAGE_SIZE){
+	while (area_left >= BASE_PAGE_SIZE) {
 		mark_used(BASE_PAGE, runner);
 		runner += BASE_PAGE_SIZE;
 		area_left -= BASE_PAGE_SIZE;
 	}
 
-	if(area_left != 0)
+	if (area_left != 0)
 		mark_used(BASE_PAGE, runner);
 }
 
@@ -364,11 +369,12 @@ static void __mark_reserved_mem(void *fdt)
 {
 	int rmem_offset = fdt_path_offset(fdt, "/reserved-memory/mmode_resv0");
 	struct cell_info ci = get_reginfo(fdt, "/reserved-memory/mmode_resv0");
-	uint8_t *rmem_reg = (uint8_t *)fdt_getprop(fdt, rmem_offset, "reg", NULL);
+	uint8_t *rmem_reg =
+		(uint8_t *)fdt_getprop(fdt, rmem_offset, "reg", NULL);
 
 	pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, rmem_reg);
 
-	if(ci.addr_cells == 2)
+	if (ci.addr_cells == 2)
 		rmem_reg += sizeof(fdt64_t);
 	else
 		rmem_reg += sizeof(fdt32_t);
@@ -385,7 +391,7 @@ static pm_t __get_ramtop(void *fdt)
 
 	pm_t base = (pm_t)fdt_load_int_ptr(ci.addr_cells, mem_reg);
 
-	if(ci.addr_cells == 2)
+	if (ci.addr_cells == 2)
 		mem_reg += sizeof(fdt64_t);
 	else
 		mem_reg += sizeof(fdt32_t);
@@ -409,7 +415,7 @@ void init_pmem(void *fdt)
 {
 	size_t max_order = 0;
 	size_t base_bits = 0;
-	size_t bits[NUM_ORDERS] = {0};
+	size_t bits[NUM_ORDERS] = { 0 };
 	stat_pmem_conf(fdt, &max_order, &base_bits, bits);
 	init_mem(max_order, bits, base_bits);
 
@@ -426,9 +432,9 @@ void init_pmem(void *fdt)
 	size_t probe_size = probe_pmap(ram_base, ram_size);
 	size_t actual_size = populate_pmap(ram_base, ram_size, pmap_base);
 
-	if(probe_size != actual_size)
-		bug("probe_size (%#lx) != actual_size (%#lx)\n",
-				probe_size, actual_size);
+	if (probe_size != actual_size)
+		bug("probe_size (%#lx) != actual_size (%#lx)\n", probe_size,
+		    actual_size);
 
 	/* mark init stack, this should be unmapped once we get to executing
 	 * processes */
diff --git a/common/proc.c b/common/proc.c
index 13d3750..9f89b7f 100644
--- a/common/proc.c
+++ b/common/proc.c
@@ -11,10 +11,10 @@ static vm_t setup_call_stack(struct tcb *t, size_t bytes)
 	pm_t offset = 0;
 	size_t pages = __pages(bytes);
 	vmflags_t flags = VM_V | VM_R | VM_W | VM_U;
-	for(size_t i = 1; i <= pages; ++i)
-	{
+	for (size_t i = 1; i <= pages; ++i) {
 		offset = alloc_page(BASE_PAGE, offset);
-		map_vpage(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i, flags, BASE_PAGE);
+		map_vpage(t->b_r, offset, PROC_STACK_TOP - BASE_PAGE_SIZE * i,
+		          flags, BASE_PAGE);
 	}
 
 	return PROC_STACK_TOP - BASE_PAGE_SIZE * pages;
@@ -29,7 +29,7 @@ stat_t init_proc(void *fdt, struct vm_branch *b)
 {
 	/* todo: cleanup or something */
 	struct tcb *t = (struct tcb *)alloc_page(BASE_PAGE, 0);
-	if(!t)
+	if (!t)
 		return ERR_OOMEM;
 
 	memset(t, 0, sizeof(struct tcb));
@@ -43,18 +43,17 @@ stat_t init_proc(void *fdt, struct vm_branch *b)
 
 	/* the binary gets to choose first what memory regions it requires */
 	t->entry = load_elf(t, get_init_base(fdt));
-	if(!t->entry)
+	if (!t->entry)
 		return ERR_ADDR;
 
 	t->proc_stack = setup_proc_stack(t, __proc_stack_size);
-	if(!t->proc_stack)
+	if (!t->proc_stack)
 		return ERR_ADDR;
 
 	t->call_stack = setup_call_stack(t, __call_stack_size);
-	if(!t->call_stack)
+	if (!t->call_stack)
 		return ERR_ADDR;
 
-
 	flush_tlb();
 
 	/* TODO: move fdt into process space */
diff --git a/common/sp_tree.c b/common/sp_tree.c
index 495b843..5097757 100644
--- a/common/sp_tree.c
+++ b/common/sp_tree.c
@@ -10,12 +10,12 @@ static void __sp_turn_left(struct sp_node *n)
 	sp_paren(n) = l;
 	sp_right(l) = n;
 
-	if(p && sp_left(p) == n)
+	if (p && sp_left(p) == n)
 		sp_left(p) = l;
 	else if (p)
 		sp_right(p) = l;
 
-	if(sp_left(n))
+	if (sp_left(n))
 		sp_lparen(n) = n;
 }
 
@@ -29,12 +29,12 @@ static void __sp_turn_right(struct sp_node *n)
 	sp_paren(n) = r;
 	sp_left(r) = n;
 
-	if(p && sp_left(p) == n)
+	if (p && sp_left(p) == n)
 		sp_left(p) = r;
 	else if (p)
 		sp_right(p) = r;
 
-	if(sp_right(n))
+	if (sp_right(n))
 		sp_rparen(n) = n;
 }
 
@@ -43,10 +43,10 @@ static int __sp_balance(struct sp_node *n)
 	int l = 0;
 	int r = 0;
 
-	if(sp_left(n))
+	if (sp_left(n))
 		l = sp_left(n)->hint + 1;
 
-	if(sp_right(n))
+	if (sp_right(n))
 		r = sp_right(n)->hint + 1;
 
 	return l - r;
@@ -57,13 +57,13 @@ static int __sp_max_hint(struct sp_node *n)
 	int l = 0;
 	int r = 0;
 
-	if(sp_left(n))
+	if (sp_left(n))
 		l = sp_left(n)->hint + 1;
 
-	if(sp_right(n))
+	if (sp_right(n))
 		r = sp_right(n)->hint + 1;
 
-	if(l > r)
+	if (l > r)
 		return l;
 	else
 		return r;
@@ -71,45 +71,44 @@ static int __sp_max_hint(struct sp_node *n)
 
 static void __sp_update(struct sp_node **root, struct sp_node *n)
 {
-	while(n){
-
+	while (n) {
 		int b = __sp_balance(n);
 		int prev_hint = n->hint;
 		struct sp_node *p = sp_paren(n);
 
-		if(b < -1) {
+		if (b < -1) {
 			/* leaning to the right */
-			if(n == *root)
+			if (n == *root)
 				*root = sp_right(n);
 
 			__sp_turn_right(n);
 		}
 
-		else if(b > 1){
+		else if (b > 1) {
 			/* leaning to the left */
-			if(n == *root)
+			if (n == *root)
 				*root = sp_left(n);
 
 			__sp_turn_left(n);
 		}
 
 		n->hint = __sp_max_hint(n);
-		if(n->hint == 0 || n->hint != prev_hint)
+		if (n->hint == 0 || n->hint != prev_hint)
 			n = p;
 		else
 			return;
 	}
 }
 
-void sp_insert(struct sp_node **root, struct sp_node *p,
-		struct sp_node *n, enum sp_dir d)
+void sp_insert(struct sp_node **root, struct sp_node *p, struct sp_node *n,
+               enum sp_dir d)
 {
-	if(!*root){
+	if (!*root) {
 		*root = n;
 		return;
 	}
 
-	if(d == LEFT)
+	if (d == LEFT)
 		sp_left(p) = n;
 	else
 		sp_right(p) = n;
@@ -123,29 +122,29 @@ static void __sp_replace_right(struct sp_node *n, struct sp_node *r)
 	struct sp_node *p = sp_paren(n);
 	struct sp_node *rp = sp_paren(r);
 
-	if(sp_left(rp) == r){
+	if (sp_left(rp) == r) {
 		sp_left(rp) = sp_right(r);
-		if(sp_right(r))
+		if (sp_right(r))
 			sp_rparen(r) = rp;
 	}
 
-	if(sp_paren(rp) == n)
+	if (sp_paren(rp) == n)
 		sp_paren(rp) = r;
 
 	sp_paren(r) = p;
 	sp_left(r) = sp_left(n);
 
-	if(sp_right(n) != r){
+	if (sp_right(n) != r) {
 		sp_right(r) = sp_right(n);
 		sp_rparen(n) = r;
 	}
 
-	if(p && sp_left(p) == n)
+	if (p && sp_left(p) == n)
 		sp_left(p) = r;
 	else if (p)
 		sp_right(p) = r;
 
-	if(sp_left(n))
+	if (sp_left(n))
 		sp_lparen(n) = r;
 }
 
@@ -154,39 +153,39 @@ static void __sp_replace_left(struct sp_node *n, struct sp_node *l)
 	struct sp_node *p = sp_paren(n);
 	struct sp_node *lp = sp_paren(l);
 
-	if(sp_right(lp) == l){
+	if (sp_right(lp) == l) {
 		sp_right(lp) = sp_left(l);
-		if(sp_left(l))
+		if (sp_left(l))
 			sp_lparen(l) = lp;
 	}
 
-	if(sp_paren(lp) == n)
+	if (sp_paren(lp) == n)
 		sp_paren(lp) = l;
 
 	sp_paren(l) = p;
 	sp_right(l) = sp_right(n);
 
-	if(sp_left(n) != l){
+	if (sp_left(n) != l) {
 		sp_left(l) = sp_left(n);
 		sp_lparen(n) = l;
 	}
 
-	if(p && sp_left(p) == n)
+	if (p && sp_left(p) == n)
 		sp_left(p) = l;
 	else if (p)
 		sp_right(p) = l;
 
-	if(sp_right(n))
+	if (sp_right(n))
 		sp_rparen(n) = l;
 }
 
 /* TODO: handle root better */
 void sp_remove(struct sp_node **root, struct sp_node *del)
 {
-	if(sp_right(del)){
+	if (sp_right(del)) {
 		struct sp_node *least = sp_first(sp_right(del));
 
-		if(del == *root)
+		if (del == *root)
 			*root = least;
 
 		__sp_replace_right(del, least);
@@ -194,10 +193,10 @@ void sp_remove(struct sp_node **root, struct sp_node *del)
 		return;
 	}
 
-	if(sp_left(del)){
+	if (sp_left(del)) {
 		struct sp_node *most = sp_last(sp_left(del));
 
-		if(del == *root)
+		if (del == *root)
 			*root = most;
 
 		__sp_replace_left(del, most);
@@ -205,7 +204,7 @@ void sp_remove(struct sp_node **root, struct sp_node *del)
 		return;
 	}
 
-	if(del == *root){
+	if (del == *root) {
 		*root = 0;
 		return;
 	}
@@ -213,7 +212,7 @@ void sp_remove(struct sp_node **root, struct sp_node *del)
 	/* empty node */
 	struct sp_node *paren = sp_paren(del);
 
-	if(sp_left(paren) == del)
+	if (sp_left(paren) == del)
 		sp_left(paren) = 0;
 	else
 		sp_right(paren) = 0;
@@ -223,14 +222,16 @@ void sp_remove(struct sp_node **root, struct sp_node *del)
 
 struct sp_node *sp_first(struct sp_node *n)
 {
-	if(!sp_left(n)) return n;
+	if (!sp_left(n))
+		return n;
 
 	return sp_first(sp_left(n));
 }
 
 struct sp_node *sp_last(struct sp_node *n)
 {
-	if(!sp_right(n)) return n;
+	if (!sp_right(n))
+		return n;
 
 	return sp_last(sp_right(n));
 }
diff --git a/common/string.c b/common/string.c
index 810a703..15416af 100644
--- a/common/string.c
+++ b/common/string.c
@@ -73,7 +73,8 @@ __weak int strcmp(const char *str1, const char *str2)
 	const char *s1 = (const char *)str1;
 	const char *s2 = (const char *)str2;
 
-	while ((*(s1++) == *(s2++)) && *s1 && *s2) ;
+	while ((*(s1++) == *(s2++)) && *s1 && *s2)
+		;
 
 	return (int)(s1[-1] - s2[-1]);
 }
@@ -84,7 +85,8 @@ __weak int strncmp(const char *str1, const char *str2, size_t num)
 	const char *s1 = (const char *)str1;
 	const char *s2 = (const char *)str2;
 
-	while ((*(s1++) == *(s2++)) && *s1 && *s2 && --num) ;
+	while ((*(s1++) == *(s2++)) && *s1 && *s2 && --num)
+		;
 
 	return (int)(s1[-1] - s2[-1]);
 }
@@ -95,7 +97,8 @@ __weak char *strchr(const char *str, int chr)
 	const char *s1 = str;
 	ssize_t num = strlen(s1);
 
-	while (num-- && *(s1--) != chr) ;
+	while (num-- && *(s1--) != chr)
+		;
 
 	if (num < 0)
 		return 0;
@@ -164,7 +167,8 @@ __weak char *strrchr(const char *str, int chr)
 	ssize_t num = strlen(str);
 	const char *s1 = (str + num) - 1;
 
-	while (num-- && *(s1--) != chr) ;
+	while (num-- && *(s1--) != chr)
+		;
 
 	if (num < 0)
 		return 0;
@@ -229,7 +233,8 @@ __weak size_t strspn(const char *str1, const char *str2)
 __weak size_t strlen(const char *str)
 {
 	const char *s1 = str;
-	while (*(s1++)) ;
+	while (*(s1++))
+		;
 
 	/* the loop overshoots by one */
 	return (size_t)(s1 - str) - 1;
@@ -239,7 +244,8 @@ __weak size_t strlen(const char *str)
 __weak size_t strnlen(const char *str, size_t num)
 {
 	const char *s1 = str;
-	while (num-- && *(s1++)) ;
+	while (num-- && *(s1++))
+		;
 
 	return (size_t)(s1 - str) - 1;
 }
@@ -263,7 +269,8 @@ __weak void *memchr(const void *ptr, int val, size_t num)
 	ssize_t n = num;
 	char c = (char)val;
 
-	while (n-- && *(p1++) != c) ;
+	while (n-- && *(p1++) != c)
+		;
 
 	if (n < 0)
 		return 0;
@@ -304,8 +311,8 @@ __weak int memcmp(const void *ptr1, const void *ptr2, size_t num)
 	const char *p1 = (const char *)ptr1;
 	const char *p2 = (const char *)ptr2;
 
-	while ((*(p1++) == *(p2++)) && --num) ;
+	while ((*(p1++) == *(p2++)) && --num)
+		;
 
 	return (int)(p1[-1] - p2[-1]);
 }
-
diff --git a/common/tcb.c b/common/tcb.c
index 8fea188..cd946bd 100644
--- a/common/tcb.c
+++ b/common/tcb.c
@@ -3,15 +3,14 @@
 #include <apos/sp_tree.h>
 #include <arch/cpu.h>
 
-static struct sp_root t_root = (struct sp_root){0};
-static struct tcb *__tcb_cache[MAX_CPUS] = {0};
+static struct sp_root t_root = (struct sp_root){ 0 };
+static struct tcb *__tcb_cache[MAX_CPUS] = { 0 };
 
-#define tcb_container(x) \
-	container_of(x, struct tcb, sp_n)
+#define tcb_container(x) container_of(x, struct tcb, sp_n)
 
 stat_t threads_insert(struct tcb *t)
 {
-	if(!sp_root(t_root)){
+	if (!sp_root(t_root)) {
 		sp_root(t_root) = &t->sp_n;
 		return OK;
 	}
@@ -19,11 +18,11 @@ stat_t threads_insert(struct tcb *t)
 	struct sp_node *n = sp_root(t_root), *p = NULL;
 	enum sp_dir d = LEFT;
 
-	while(n){
+	while (n) {
 		struct tcb *tc = tcb_container(n);
 		p = n;
 
-		if(t->tid < tc->tid){
+		if (t->tid < tc->tid) {
 			n = sp_left(n);
 			d = LEFT;
 		}
@@ -42,13 +41,13 @@ struct tcb *threads_find(id_t tid)
 {
 	struct sp_node *n = sp_root(t_root);
 
-	while(n){
+	while (n) {
 		struct tcb *t = tcb_container(n);
 
-		if(t->tid == tid)
+		if (t->tid == tid)
 			return t;
 
-		if(t->tid < tid)
+		if (t->tid < tid)
 			n = sp_left(n);
 		else
 			n = sp_right(n);
diff --git a/common/uapi/conf.c b/common/uapi/conf.c
index 6f4faff..56e07a1 100644
--- a/common/uapi/conf.c
+++ b/common/uapi/conf.c
@@ -6,14 +6,17 @@ size_t __call_stack_size = SZ_2M;
 
 vm_t sys_conf(vm_t param, vm_t val, vm_t u0, vm_t u1)
 {
-	UNUSED(u0); UNUSED(u1);
+	UNUSED(u0);
+	UNUSED(u1);
 	/* no parameters supported atm */
 	return 0;
 }
 
 vm_t sys_poweroff(vm_t type, vm_t u0, vm_t u1, vm_t u2)
 {
-	UNUSED(u0); UNUSED(u1); UNUSED(u2);
+	UNUSED(u0);
+	UNUSED(u1);
+	UNUSED(u2);
 	/* powering off not supported yet, you're stuck here >:D */
 	return 0;
 }
diff --git a/common/uapi/ipc.c b/common/uapi/ipc.c
index 5abbaeb..a3b29f8 100644
--- a/common/uapi/ipc.c
+++ b/common/uapi/ipc.c
@@ -3,9 +3,11 @@
 
 vm_t sys_ipc_server(vm_t callback, vm_t u0, vm_t u1, vm_t u2)
 {
-	UNUSED(u0); UNUSED(u1); UNUSED(u2);
+	UNUSED(u0);
+	UNUSED(u1);
+	UNUSED(u2);
 	struct tcb *r = cur_tcb();
-	if(r->callback) /* server can't be reinitialized */
+	if (r->callback) /* server can't be reinitialized */
 		return 1;
 
 	r->callback = callback;
@@ -21,7 +23,8 @@ vm_t sys_ipc_req(vm_t pid, vm_t d0, vm_t d1, vm_t d2)
 
 vm_t sys_ipc_resp(vm_t pid, vm_t ret, vm_t u0, vm_t u1)
 {
-	UNUSED(u0); UNUSED(u1);
+	UNUSED(u0);
+	UNUSED(u1);
 	struct tcb *r = get_tcb(pid);
 	/* something like return_from_callback(t, r) */
 	return 0; /* oh yeah probably unreachable? */
diff --git a/common/uapi/mem.c b/common/uapi/mem.c
index 0a88eda..f54131f 100644
--- a/common/uapi/mem.c
+++ b/common/uapi/mem.c
@@ -5,7 +5,8 @@
 
 vm_t sys_req_mem(vm_t size, vm_t flags, vm_t u0, vm_t u1)
 {
-	UNUSED(u0); UNUSED(u1);
+	UNUSED(u0);
+	UNUSED(u1);
 	/* proc_tcb should give the tcb of the TID currently running */
 	struct tcb *r = cur_tcb();
 	return alloc_uvmem(r, size, flags);
@@ -20,9 +21,11 @@ vm_t sys_req_fixmem(vm_t start, vm_t size, vm_t flags, vm_t u0)
 
 vm_t sys_free_mem(vm_t start, vm_t u0, vm_t u1, vm_t u2)
 {
-	UNUSED(u0); UNUSED(u1); UNUSED(u2);
+	UNUSED(u0);
+	UNUSED(u1);
+	UNUSED(u2);
 	struct tcb *r = cur_tcb();
-	if(start > __pre_top && start < __post_base)
+	if (start > __pre_top && start < __post_base)
 		free_uvmem(r, start);
 	else
 		free_devmem(r, start);
diff --git a/common/uapi/proc.c b/common/uapi/proc.c
index dd05bad..e4673b5 100644
--- a/common/uapi/proc.c
+++ b/common/uapi/proc.c
@@ -12,7 +12,9 @@
  */
 vm_t sys_fork(vm_t pid, vm_t u0, vm_t u1, vm_t u2)
 {
-	UNUSED(u0); UNUSED(u1); UNUSED(u2);
+	UNUSED(u0);
+	UNUSED(u1);
+	UNUSED(u2);
 	/* TODO: create new thread in the same process family */
 	return 0;
 }
@@ -25,21 +27,25 @@ vm_t sys_exec(vm_t pid, vm_t bin, vm_t argc, vm_t argv)
 
 vm_t sys_signal(vm_t pid, vm_t signal, vm_t u0, vm_t u1)
 {
-	UNUSED(u0); UNUSED(u1);
+	UNUSED(u0);
+	UNUSED(u1);
 	/* TODO: signals? */
 	return 0;
 }
 
 vm_t sys_switch(vm_t pid, vm_t u0, vm_t u1, vm_t u2)
 {
-	UNUSED(u0); UNUSED(u1); UNUSED(u2);
+	UNUSED(u0);
+	UNUSED(u1);
+	UNUSED(u2);
 	/* TODO: switch to process */
 	return 0;
 }
 
 vm_t sys_sync(vm_t buf, vm_t size, vm_t u0, vm_t u1)
 {
-	UNUSED(u0); UNUSED(u1);
+	UNUSED(u0);
+	UNUSED(u1);
 	/* check that only the process manager can use this syscall, otherwise
 	 * just dump process info into the buffer (I guess, not sure if this
 	 * will be quite required */
diff --git a/common/vmem.c b/common/vmem.c
index fe77634..d0d40ec 100644
--- a/common/vmem.c
+++ b/common/vmem.c
@@ -22,7 +22,7 @@ vm_t alloc_fixed_uvmem(struct tcb *t, vm_t start, size_t size, vmflags_t flags)
 stat_t free_uvmem(struct tcb *t, vm_t va)
 {
 	struct mem_region *m = find_used_region(&t->sp_r, va);
-	if(!m)
+	if (!m)
 		return -1;
 
 	pm_t pa = __addr(m->end - m->start);
@@ -32,24 +32,27 @@ stat_t free_uvmem(struct tcb *t, vm_t va)
 	return 0;
 }
 
-stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
+stat_t alloc_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr,
+                           vmflags_t flags, enum mm_order order)
 {
 	*offset = alloc_page(order, *offset);
-	if(!*offset)
+	if (!*offset)
 		return REGION_TRY_AGAIN; /* try again */
 
 	map_vpage(b, *offset, vaddr, flags, order);
 	return OK;
 }
 
-stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr, vmflags_t flags, enum mm_order order)
+stat_t free_uvmem_wrapper(struct vm_branch *b, pm_t *offset, vm_t vaddr,
+                          vmflags_t flags, enum mm_order order)
 {
-	UNUSED(flags); UNUSED(offset);
+	UNUSED(flags);
+	UNUSED(offset);
 
 	pm_t paddr = 0;
 	enum mm_order v_order = 0;
 	stat_vpage(b, vaddr, &paddr, &v_order, 0);
-	if(order != v_order)
+	if (order != v_order)
 		return REGION_TRY_AGAIN;
 
 	unmap_vpage(b, vaddr);