Added libgui

22 files changed, 899 insertions, 0 deletions

diff --git a/libc/Makefile b/libc/Makefile
new file mode 100644
index 0000000..f4286ae
--- /dev/null
+++ b/libc/Makefile
@@ -0,0 +1,36 @@
+# MIT License, Copyright (c) 2020 Marvin Borner
+
+# TODO: Remove serial and cpu from libc?
+COBJS = str.o \
+	mem.o \
+	math.o \
+	conv.o \
+	print.o \
+	serial.o \
+	cpu.o \
+	sys.o \
+	list.o
+CC = ../cross/opt/bin/i686-elf-gcc
+LD = ../cross/opt/bin/i686-elf-ld
+OC = ../cross/opt/bin/i686-elf-ar
+
+# Flags to make the binary smaller TODO: Remove after indirect pointer support!
+CSFLAGS = -mpreferred-stack-boundary=2 -fno-asynchronous-unwind-tables -Os
+
+CFLAGS = $(CSFLAGS) -Wall -Wextra -nostdlib -nostdinc -ffreestanding -fno-builtin -mgeneral-regs-only -std=c99 -m32 -pedantic-errors -Iinc/
+
+%.o: %.c
+	@$(CC) -c $(CFLAGS) $< -o $@
+
+libc: CFLAGS += -Duserspace -fPIE
+libc: $(COBJS)
+	@mkdir -p ../build/
+	@$(AR) qc ../build/libc.a $+
+
+libk: CFLAGS += -Dkernel
+libk: $(COBJS)
+	@mkdir -p ../build/
+	@$(AR) qc ../build/libk.a $+
+
+clean:
+	@find . -name "*.o" -type f -delete
diff --git a/libc/conv.c b/libc/conv.c
new file mode 100644
index 0000000..3bde4ec
--- /dev/null
+++ b/libc/conv.c
@@ -0,0 +1,144 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <def.h>
+#include <math.h>
+#include <mem.h>
+#include <str.h>
+
+static const char HTOA_TABLE[] = "0123456789ABCDEF";
+static const char ITOA_TABLE[] = "0123456789";
+
+int atoi(char *str)
+{
+	u32 s_str = strlen(str);
+	if (!s_str)
+		return 0;
+
+	u8 negative = 0;
+	if (str[0] == '-')
+		negative = 1;
+
+	u32 i = 0;
+	if (negative)
+		i++;
+
+	int ret = 0;
+	for (; i < s_str; i++) {
+		ret += (str[i] - '0') * pow(10, (int)((s_str - i) - 1));
+	}
+
+	if (negative)
+		ret *= -1;
+	return ret;
+}
+
+char *htoa(u32 n)
+{
+	char *ret = (char *)malloc(10);
+
+	int i = 0;
+	while (n) {
+		ret[i++] = HTOA_TABLE[n & 0xF];
+		n >>= 4;
+	}
+
+	if (!i) {
+		ret[0] = '0';
+		i++;
+	}
+
+	for (; i <= 9; i++)
+		ret[i] = 0;
+
+	char *aux = strdup(ret);
+	free(ret);
+	ret = aux;
+
+	strinv(ret);
+	return ret;
+}
+
+int htoi(char *str)
+{
+	u32 s_str = strlen(str);
+
+	u32 i = 0;
+	int ret = 0;
+	for (; i < s_str; i++) {
+		char c = str[i];
+		int aux = 0;
+		if (c >= '0' && c <= '9')
+			aux = c - '0';
+		else if (c >= 'A' && c <= 'F')
+			aux = (c - 'A') + 10;
+
+		ret += aux * pow(16, (int)((s_str - i) - 1));
+	}
+
+	return ret;
+}
+
+char *itoa(int n)
+{
+	if (!n) {
+		char *ret = (char *)malloc(2);
+		ret[0] = '0';
+		ret[1] = 0;
+		return ret;
+	}
+	u8 negative = (u8)(n < 0);
+	if (negative)
+		n *= -1;
+
+	int sz;
+	for (sz = 0; n % pow(10, sz) != n; sz++) {
+	}
+
+	char *ret = (char *)malloc((u32)(sz + 1));
+
+	for (int i = 0; i < sz; i++) {
+		int digit = (n % pow(10, i + 1)) / pow(10, i);
+		ret[i] = ITOA_TABLE[digit];
+	}
+	ret[sz] = 0;
+
+	if (negative) {
+		char *aux = (char *)malloc((u32)(sz + 2));
+		strcpy(aux, ret);
+		aux[sz] = '-';
+		aux[sz + 1] = 0;
+		free(ret);
+		ret = aux;
+	}
+
+	strinv(ret);
+	return ret;
+}
+
+char *conv_base(int value, char *result, int base, int is_signed)
+{
+	if (base < 2 || base > 36) {
+		*result = '\0';
+		return result;
+	}
+
+	char *ptr = result, *ptr1 = result, tmp_char;
+	int tmp_value;
+
+	do {
+		tmp_value = value;
+		value /= base;
+		*ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"
+			[35 + (tmp_value - value * base)];
+	} while (value);
+
+	if (is_signed && tmp_value < 0)
+		*ptr++ = '-';
+	*ptr-- = '\0';
+	while (ptr1 < ptr) {
+		tmp_char = *ptr;
+		*ptr-- = *ptr1;
+		*ptr1++ = tmp_char;
+	}
+	return result;
+}
diff --git a/libc/cpu.c b/libc/cpu.c
new file mode 100644
index 0000000..5ed9de9
--- /dev/null
+++ b/libc/cpu.c
@@ -0,0 +1,75 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// This file is a wrapper around some CPU asm calls
+
+#include <def.h>
+
+u8 inb(u16 port)
+{
+	u8 value;
+	__asm__ volatile("inb %1, %0" : "=a"(value) : "Nd"(port));
+	return value;
+}
+
+u16 inw(u16 port)
+{
+	u16 value;
+	__asm__ volatile("inw %1, %0" : "=a"(value) : "Nd"(port));
+	return value;
+}
+
+u32 inl(u16 port)
+{
+	u32 value;
+	__asm__ volatile("inl %1, %0" : "=a"(value) : "Nd"(port));
+	return value;
+}
+
+void insl(u16 port, void *addr, int n)
+{
+	__asm__ volatile("cld; rep insl"
+			 : "=D"(addr), "=c"(n)
+			 : "d"(port), "0"(addr), "1"(n)
+			 : "memory", "cc");
+}
+
+void outb(u16 port, u8 data)
+{
+	__asm__ volatile("outb %0, %1" ::"a"(data), "Nd"(port));
+}
+
+void outw(u16 port, u16 data)
+{
+	__asm__ volatile("outw %0, %1" ::"a"(data), "Nd"(port));
+}
+
+void outl(u16 port, u32 data)
+{
+	__asm__ volatile("outl %0, %1" ::"a"(data), "Nd"(port));
+}
+
+void cli()
+{
+	__asm__ volatile("cli");
+}
+
+void sti()
+{
+	__asm__ volatile("sti");
+}
+
+void hlt()
+{
+	__asm__ volatile("hlt");
+}
+
+void idle()
+{
+	while (1)
+		hlt();
+}
+
+void loop()
+{
+	cli();
+	idle();
+}
diff --git a/libc/inc/arg.h b/libc/inc/arg.h
new file mode 100644
index 0000000..73e592d
--- /dev/null
+++ b/libc/inc/arg.h
@@ -0,0 +1,11 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef ARG_H
+#define ARG_H
+
+typedef __builtin_va_list va_list;
+#define va_start __builtin_va_start
+#define va_end __builtin_va_end
+#define va_arg __builtin_va_arg
+
+#endif
diff --git a/libc/inc/assert.h b/libc/inc/assert.h
new file mode 100644
index 0000000..91c4ccd
--- /dev/null
+++ b/libc/inc/assert.h
@@ -0,0 +1,14 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef ASSERT_H
+#define ASSERT_H
+
+#include <print.h>
+
+#define assert(exp)                                                                                \
+	if (!(exp)) {                                                                              \
+		printf("%s:%d: %s: Assertion '%s' failed\n", __FILE__, __LINE__, __func__, #exp);  \
+		__asm__ volatile("cli\nhlt");                                                      \
+	}
+
+#endif
diff --git a/libc/inc/conv.h b/libc/inc/conv.h
new file mode 100644
index 0000000..d878deb
--- /dev/null
+++ b/libc/inc/conv.h
@@ -0,0 +1,15 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef CONV_H
+#define CONV_H
+
+#include <def.h>
+
+int atoi(char *str);
+char *htoa(u32 n);
+int htoi(char *str);
+char *itoa(int n);
+
+char *conv_base(int value, char *result, int base, int is_signed);
+
+#endif
diff --git a/libc/inc/cpu.h b/libc/inc/cpu.h
new file mode 100644
index 0000000..2d367cb
--- /dev/null
+++ b/libc/inc/cpu.h
@@ -0,0 +1,30 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef CPU_H
+#define CPU_H
+
+#include <def.h>
+
+u8 inb(u16 port);
+u16 inw(u16 port);
+u32 inl(u16 port);
+void insl(u16 port, void *addr, int n);
+
+void outb(u16 port, u8 data);
+void outw(u16 port, u16 data);
+void outl(u16 port, u32 data);
+void cli();
+void sti();
+void hlt();
+void idle();
+void loop();
+
+static inline void spinlock(int *ptr)
+{
+	int prev;
+	do
+		__asm__ volatile("lock xchgl %0,%1" : "=a"(prev) : "m"(*ptr), "a"(1));
+	while (prev);
+}
+
+#endif
diff --git a/libc/inc/def.h b/libc/inc/def.h
new file mode 100644
index 0000000..42939a0
--- /dev/null
+++ b/libc/inc/def.h
@@ -0,0 +1,28 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef DEF_H
+#define DEF_H
+
+/**
+ * Types
+ */
+
+typedef signed char s8;
+typedef unsigned char u8;
+
+typedef signed short s16;
+typedef unsigned short u16;
+
+typedef signed long s32;
+typedef unsigned long u32;
+
+typedef signed long long s64;
+typedef unsigned long long u64;
+
+/**
+ * Macros
+ */
+
+#define NULL ((void *)0)
+
+#endif
diff --git a/libc/inc/list.h b/libc/inc/list.h
new file mode 100644
index 0000000..5deaf59
--- /dev/null
+++ b/libc/inc/list.h
@@ -0,0 +1,25 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef LIST_H
+#define LIST_H
+
+#include <def.h>
+
+struct list {
+	struct node *head;
+};
+
+struct node {
+	void *data;
+	int nonce;
+	struct node *next;
+	struct node *prev;
+};
+
+struct list *list_new();
+/* struct node *list_new_node(); */ // TODO: Make node-specific things static/private?
+/* void list_add_node(struct list *list, struct node *node); */
+void list_add(struct list *list, void *data);
+void list_remove(struct list *list, struct node *node);
+
+#endif
diff --git a/libc/inc/math.h b/libc/inc/math.h
new file mode 100644
index 0000000..268e3e7
--- /dev/null
+++ b/libc/inc/math.h
@@ -0,0 +1,10 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef MATH_H
+#define MATH_H
+
+#include <def.h>
+
+int pow(int base, int exp);
+
+#endif
diff --git a/libc/inc/mem.h b/libc/inc/mem.h
new file mode 100644
index 0000000..0030b3d
--- /dev/null
+++ b/libc/inc/mem.h
@@ -0,0 +1,27 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef MEM_H
+#define MEM_H
+
+#include <def.h>
+
+// Huh
+#ifdef kernel
+#define malloc(n) (void *)((HEAP += n) - n) // TODO: Implement real/better malloc/free
+#define free(ptr)
+#elif defined(userspace)
+#include <sys.h>
+#define malloc(n) (void *)sys1(SYS_MALLOC, n)
+#define free(ptr) (void)(sys1(SYS_FREE, (int)ptr))
+#else
+#error "No lib target specified. Please use -Dkernel or -Duserspace"
+#endif
+
+u32 HEAP;
+u32 HEAP_START;
+
+void *memcpy(void *dst, const void *src, u32 n);
+void *memset(void *dst, int c, u32 n);
+int memcmp(const void *s1, const void *s2, u32 n);
+
+#endif
diff --git a/libc/inc/print.h b/libc/inc/print.h
new file mode 100644
index 0000000..04668b2
--- /dev/null
+++ b/libc/inc/print.h
@@ -0,0 +1,14 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// I may (re)move this in the future // TODO
+
+#ifndef PRINT_H
+#define PRINT_H
+
+#include "arg.h"
+
+int printf(const char *format, ...);
+int vprintf(const char *format, va_list ap);
+int vsprintf(char *str, const char *format, va_list ap);
+int print(const char *str);
+
+#endif
diff --git a/libc/inc/serial.h b/libc/inc/serial.h
new file mode 100644
index 0000000..6511952
--- /dev/null
+++ b/libc/inc/serial.h
@@ -0,0 +1,9 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef SERIAL_H
+#define SERIAL_H
+
+void serial_install();
+void serial_print(const char *data);
+
+#endif
diff --git a/libc/inc/str.h b/libc/inc/str.h
new file mode 100644
index 0000000..65774e7
--- /dev/null
+++ b/libc/inc/str.h
@@ -0,0 +1,17 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#ifndef STR_H
+#define STR_H
+
+#include <def.h>
+
+u32 strlen(const char *s);
+char *strcpy(char *dst, const char *src);
+char *strchr(const char *s, int c);
+char *strcat(char *dst, const char *src);
+int strcmp(const char *s1, const char *s2);
+int strncmp(const char *s1, const char *s2, u32 n);
+char *strinv(char *s);
+char *strdup(const char *s);
+
+#endif
diff --git a/libc/inc/sys.h b/libc/inc/sys.h
new file mode 100644
index 0000000..16d3c4f
--- /dev/null
+++ b/libc/inc/sys.h
@@ -0,0 +1,27 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// Syscall implementation
+
+#ifndef SYS_H
+#define SYS_H
+
+enum sys { SYS_LOOP, SYS_MALLOC, SYS_FREE, SYS_EXEC, SYS_EXIT };
+
+int sys0(enum sys num);
+int sys1(enum sys num, int d1);
+int sys2(enum sys num, int d1, int d2);
+int sys3(enum sys num, int d1, int d2, int d3);
+int sys4(enum sys num, int d1, int d2, int d3, int d4);
+int sys5(enum sys num, int d1, int d2, int d3, int d4, int d5);
+
+/**
+ * Wrappers
+ */
+
+#define loop() sys0(SYS_LOOP)
+#define exec(path) sys1(SYS_EXEC, (int)path)
+#define exit()                                                                                     \
+	sys0(SYS_EXIT);                                                                            \
+	while (1) {                                                                                \
+	}
+
+#endif
diff --git a/libc/list.c b/libc/list.c
new file mode 100644
index 0000000..c36d6e1
--- /dev/null
+++ b/libc/list.c
@@ -0,0 +1,74 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <def.h>
+#include <list.h>
+#include <mem.h>
+
+static int nonce = 0;
+
+struct list *list_new()
+{
+	struct list *list = malloc(sizeof(*list));
+	list->head = NULL;
+	return list;
+}
+
+struct node *list_new_node()
+{
+	struct node *node = malloc(sizeof(*node));
+	node->data = NULL;
+	node->prev = NULL;
+	node->next = NULL;
+	node->nonce = nonce++;
+	return node;
+}
+
+void list_add_node(struct list *list, struct node *node)
+{
+	if (list == NULL)
+		return;
+
+	if (list->head == NULL) {
+		list->head = node;
+		return;
+	}
+
+	struct node *iterator = list->head;
+	while (iterator != NULL) {
+		if (iterator->next == NULL) {
+			iterator->next = node;
+			node->prev = iterator;
+			break;
+		}
+		iterator = iterator->next;
+	}
+}
+
+void list_add(struct list *list, void *data)
+{
+	struct node *node = list_new_node();
+	node->data = data;
+	list_add_node(list, node);
+}
+
+// Maybe list_remove_node?
+void list_remove(struct list *list, struct node *node)
+{
+	if (list == NULL || list->head == NULL)
+		return;
+
+	if (list->head == node) {
+		list->head = list->head->next;
+		return;
+	}
+
+	struct node *iterator = list->head->next;
+	while (iterator != node) {
+		iterator = iterator->next;
+		if (iterator == NULL)
+			return;
+	}
+
+	iterator->prev->next = iterator->next;
+	iterator->next->prev = iterator->prev;
+}
diff --git a/libc/math.c b/libc/math.c
new file mode 100644
index 0000000..9cd9cea
--- /dev/null
+++ b/libc/math.c
@@ -0,0 +1,15 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+int pow(int base, int exp)
+{
+	if (exp < 0)
+		return 0;
+
+	if (!exp)
+		return 1;
+
+	int ret = base;
+	for (int i = 1; i < exp; i++)
+		ret *= base;
+	return ret;
+}
diff --git a/libc/mem.c b/libc/mem.c
new file mode 100644
index 0000000..58c337b
--- /dev/null
+++ b/libc/mem.c
@@ -0,0 +1,35 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <def.h>
+#include <print.h>
+#include <sys.h>
+
+void *memcpy(void *dst, const void *src, u32 n)
+{
+	const char *sp = (const char *)src;
+	char *dp = (char *)dst;
+	for (; n != 0; n--)
+		*dp++ = *sp++;
+	return dst;
+}
+
+void *memset(void *dst, char val, u32 n)
+{
+	char *temp = (char *)dst;
+	for (; n != 0; n--)
+		*temp++ = val;
+	return dst;
+}
+
+int memcmp(const void *s1, const void *s2, u32 n)
+{
+	const u8 *a = (const u8 *)s1;
+	const u8 *b = (const u8 *)s2;
+	for (u32 i = 0; i < n; i++) {
+		if (a[i] < b[i])
+			return -1;
+		else if (b[i] < a[i])
+			return 1;
+	}
+	return 0;
+}
diff --git a/libc/print.c b/libc/print.c
new file mode 100644
index 0000000..84c4975
--- /dev/null
+++ b/libc/print.c
@@ -0,0 +1,104 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <arg.h>
+#include <conv.h>
+#include <def.h>
+#include <mem.h>
+#include <serial.h>
+#include <str.h>
+
+static void append(char *dest, char *src, int index)
+{
+	for (u32 i = index; i < strlen(src) + index; i++)
+		dest[i] = src[i - index];
+	dest[index + strlen(src)] = 0;
+}
+
+int vsprintf(char *str, const char *format, va_list ap)
+{
+	u8 ready_to_format = 0;
+
+	int i = 0;
+	char buf = 0;
+	char format_buffer[20] = "\0";
+
+	for (; *format; format++) {
+		if (ready_to_format) {
+			ready_to_format = 0;
+
+			if (*format == '%') {
+				str[i] = '%';
+				continue;
+			}
+
+			buf = *format;
+
+			// TODO: Improve this repetitive code
+			if (buf == 's') {
+				char *string = va_arg(ap, char *);
+				append(str, string, i);
+				i = strlen(str);
+			} else if (buf == 'x') {
+				conv_base(va_arg(ap, u32), format_buffer, 16, 0);
+				append(str, format_buffer, i);
+				i = strlen(str);
+			} else if (buf == 'd' || buf == 'i') {
+				conv_base(va_arg(ap, s32), format_buffer, 10, 1);
+				append(str, format_buffer, i);
+				i = strlen(str);
+			} else if (buf == 'u') {
+				conv_base(va_arg(ap, u32), format_buffer, 10, 0);
+				append(str, format_buffer, i);
+				i = strlen(str);
+			} else if (buf == 'o') {
+				conv_base(va_arg(ap, u32), format_buffer, 8, 0);
+				append(str, format_buffer, i);
+				i = strlen(str);
+			} else if (buf == 'b') {
+				conv_base(va_arg(ap, u32), format_buffer, 2, 0);
+				append(str, format_buffer, i);
+				i = strlen(str);
+			} else if (buf == 'c') {
+				str[i] = (char)va_arg(ap, int);
+				i++;
+			}
+		} else {
+			if (*format == '%')
+				ready_to_format = 1;
+			else {
+				str[i] = *format;
+				i++;
+			}
+		}
+
+		format_buffer[0] = '\0';
+	}
+
+	return strlen(str);
+}
+
+int vprintf(const char *format, va_list ap)
+{
+	char buf[1024];
+	memset(buf, 0, 1024);
+	int len = vsprintf(buf, format, ap);
+	serial_print(buf); // TODO: Remove temporary serial print
+	return len;
+}
+
+// TODO: Fix printf for *very* large strings (serial works)
+int printf(const char *format, ...)
+{
+	va_list ap;
+	va_start(ap, format);
+	int len = vprintf(format, ap);
+	va_end(ap);
+
+	return len;
+}
+
+int print(const char *str)
+{
+	serial_print(str);
+	return strlen(str);
+}
diff --git a/libc/serial.c b/libc/serial.c
new file mode 100644
index 0000000..28de140
--- /dev/null
+++ b/libc/serial.c
@@ -0,0 +1,34 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <cpu.h>
+#include <def.h>
+#include <str.h>
+
+void serial_install()
+{
+	outb(0x3f8 + 1, 0x00);
+	outb(0x3f8 + 3, 0x80);
+	outb(0x3f8 + 0, 0x03);
+	outb(0x3f8 + 1, 0x00);
+	outb(0x3f8 + 3, 0x03);
+	outb(0x3f8 + 2, 0xC7);
+	outb(0x3f8 + 4, 0x0B);
+}
+
+int is_transmit_empty()
+{
+	return inb(0x3f8 + 5) & 0x20;
+}
+
+void serial_put(char ch)
+{
+	while (is_transmit_empty() == 0)
+		;
+	outb(0x3f8, (u8)ch);
+}
+
+void serial_print(const char *data)
+{
+	for (u32 i = 0; i < strlen(data); i++)
+		serial_put(data[i]);
+}
diff --git a/libc/str.c b/libc/str.c
new file mode 100644
index 0000000..d1ee325
--- /dev/null
+++ b/libc/str.c
@@ -0,0 +1,98 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+
+#include <def.h>
+#include <mem.h>
+
+u32 strlen(const char *s)
+{
+	const char *ss = s;
+	while (*ss)
+		ss++;
+	return ss - s;
+}
+
+char *strcpy(char *dst, const char *src)
+{
+	char *q = dst;
+	const char *p = src;
+	char ch;
+
+	do {
+		*q++ = ch = *p++;
+	} while (ch);
+
+	return dst;
+}
+
+int strcmp(const char *s1, const char *s2)
+{
+	const u8 *c1 = (const u8 *)s1;
+	const u8 *c2 = (const u8 *)s2;
+	u8 ch;
+	int d = 0;
+
+	while (1) {
+		d = (int)(ch = *c1++) - (int)*c2++;
+		if (d || !ch)
+			break;
+	}
+
+	return d;
+}
+
+int strncmp(const char *s1, const char *s2, u32 n)
+{
+	const u8 *c1 = (const u8 *)s1;
+	const u8 *c2 = (const u8 *)s2;
+	u8 ch;
+	int d = 0;
+
+	while (n--) {
+		d = (int)(ch = *c1++) - (int)*c2++;
+		if (d || !ch)
+			break;
+	}
+
+	return d;
+}
+
+char *strchr(const char *s, int c)
+{
+	while (*s != (char)c) {
+		if (!*s)
+			return NULL;
+		s++;
+	}
+
+	return (char *)s;
+}
+
+char *strcat(char *dst, const char *src)
+{
+	strcpy(strchr(dst, '\0'), src);
+	return dst;
+}
+
+char *strinv(char *s)
+{
+	u32 s_str = strlen(s);
+
+	int iterations = (int)s_str / 2;
+	for (int i = 0; i < iterations; i++) {
+		char aux = s[i];
+		s[i] = s[(s_str - i) - 1];
+		s[(s_str - i) - 1] = aux;
+	}
+	return s;
+}
+
+char *strdup(const char *s)
+{
+	int l = strlen(s) + 1;
+	char *d = malloc(l);
+
+	if (d)
+		memcpy(d, s, l);
+
+	return d;
+}
diff --git a/libc/sys.c b/libc/sys.c
new file mode 100644
index 0000000..d676445
--- /dev/null
+++ b/libc/sys.c
@@ -0,0 +1,57 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// Syscall implementation
+
+#include <sys.h>
+
+/**
+ * Definitions
+ */
+
+int sys0(enum sys num)
+{
+	int a;
+	__asm__ volatile("int $0x80" : "=a"(a) : "0"(num));
+	return a;
+}
+
+int sys1(enum sys num, int d1)
+{
+	int a;
+	__asm__ volatile("int $0x80" : "=a"(a) : "0"(num), "b"((int)d1));
+	return a;
+}
+
+int sys2(enum sys num, int d1, int d2)
+{
+	int a;
+	__asm__ volatile("int $0x80" : "=a"(a) : "0"(num), "b"((int)d1), "c"((int)d2));
+	return a;
+}
+
+int sys3(enum sys num, int d1, int d2, int d3)
+{
+	int a;
+	__asm__ volatile("int $0x80"
+			 : "=a"(a)
+			 : "0"(num), "b"((int)d1), "c"((int)d2), "d"((int)d3));
+	return a;
+}
+
+int sys4(enum sys num, int d1, int d2, int d3, int d4)
+{
+	int a;
+	__asm__ volatile("int $0x80"
+			 : "=a"(a)
+			 : "0"(num), "b"((int)d1), "c"((int)d2), "d"((int)d3), "S"((int)d4));
+	return a;
+}
+
+int sys5(enum sys num, int d1, int d2, int d3, int d4, int d5)
+{
+	int a;
+	__asm__ volatile("int $0x80"
+			 : "=a"(a)
+			 : "0"(num), "b"((int)d1), "c"((int)d2), "d"((int)d3), "S"((int)d4),
+			   "D"((int)d5));
+	return a;
+}