aboutsummaryrefslogtreecommitdiff
path: root/common
diff options
context:
space:
mode:
Diffstat (limited to 'common')
-rw-r--r--common/bits.c22
-rw-r--r--common/debug.c433
-rw-r--r--common/dmem.c39
-rw-r--r--common/elf.c33
-rw-r--r--common/fdt.c12
-rw-r--r--common/initrd.c20
-rw-r--r--common/mem.c4
-rw-r--r--common/mem_nodes.c51
-rw-r--r--common/mem_regions.c145
-rw-r--r--common/pmem.c136
-rw-r--r--common/proc.c15
-rw-r--r--common/sp_tree.c81
-rw-r--r--common/string.c25
-rw-r--r--common/tcb.c19
-rw-r--r--common/uapi/conf.c7
-rw-r--r--common/uapi/ipc.c9
-rw-r--r--common/uapi/mem.c9
-rw-r--r--common/uapi/proc.c14
-rw-r--r--common/vmem.c15
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);
generated by cgit v1.3 (git 2.53.0) at 2026-08-27 01:40:49 +0000