Merge remote-tracking branch 'Userspace/master'

Userspace/libc/src/InitArray.c

@@ -0,0 +1,22 @@
+// extern void (*__preinit_array_start[])(void) __attribute__((weak));
+// extern void (*__preinit_array_end[])(void) __attribute__((weak));
+// extern void (*__init_array_start[])(void) __attribute__((weak));
+// extern void (*__init_array_end[])(void) __attribute__((weak));
+// extern void (*__fini_array_start []) (void) __attribute__((weak));
+// extern void (*__fini_array_end []) (void) __attribute__((weak));
+
+typedef void (*fct)(void);
+extern fct __init_array_start[0], __init_array_end[0];
+extern fct __fini_array_start[0], __fini_array_end[0];
+
+void __libc_init_array(void)
+{
+	for (fct *func = __init_array_start; func != __init_array_end; func++)
+		(*func)();
+}
+
+void __libc_fini_array(void)
+{
+	for (fct *func = __fini_array_start; func != __fini_array_end; func++)
+		(*func)();
+}

Userspace/libc/src/Lock.cpp

@@ -0,0 +1,35 @@
+#include "lock.hpp"
+#include <stdio.h>
+
+void LockClass::DeadLock(SpinLockData Lock)
+{
+	fprintf(stdout, "Potential deadlock in lock '%s' held by '%s'! %ld locks in queue.",
+			Lock.AttemptingToGet, Lock.CurrentHolder, Lock.Count);
+}
+
+int LockClass::Lock(const char *FunctionName)
+{
+	LockData.AttemptingToGet = FunctionName;
+Retry:
+	unsigned int i = 0;
+	while (__atomic_exchange_n(&IsLocked, true, __ATOMIC_ACQUIRE) && ++i < 0x10000000)
+		;
+	if (i >= 0x10000000)
+	{
+		DeadLock(LockData);
+		goto Retry;
+	}
+	LockData.Count++;
+	LockData.CurrentHolder = FunctionName;
+	__sync_synchronize();
+	return 0;
+}
+
+int LockClass::Unlock()
+{
+	__sync_synchronize();
+	__atomic_store_n(&IsLocked, false, __ATOMIC_RELEASE);
+	LockData.Count--;
+	IsLocked = false;
+	return 0;
+}

Userspace/libc/src/Makefile

@@ -0,0 +1,59 @@
+# Config file
+include ../../../Makefile.conf
+
+NAME=c
+
+ifeq ($(USERSPACE_STATIC_LIBS), 1)
+OBJECT_NAME := lib$(NAME).a
+else
+OBJECT_NAME := lib$(NAME).so
+endif
+
+OUTPUT_DIR=../../out/lib/
+SYSROOT = --sysroot=../../out/
+
+CC = ../../../$(COMPILER_PATH)/$(COMPILER_ARCH)gcc
+AS = ../../../$(COMPILER_PATH)/$(COMPILER_ARCH)as
+AR = ../../../$(COMPILER_PATH)/$(COMPILER_ARCH)ar
+
+C_SOURCES = $(shell find ./ -type f -name '*.c')
+CPP_SOURCES = $(shell find ./ -type f -name '*.cpp')
+S_SOURCES = $(shell find ./ -type f -name '*.S')
+OBJ = ${C_SOURCES:.c=.o} ${CPP_SOURCES:.cpp=.o} ${S_SOURCES:.S=.o}
+
+ifeq ($(OSARCH), amd64)
+ASM_ARCH := elf64
+else ifeq ($(OSARCH), i386)
+ASM_ARCH := elf32
+endif
+
+CFLAGS := -fvisibility=hidden -fPIC -I../include -I../../out/include
+
+ifeq ($(DEBUG), 1)
+	CFLAGS += -DDEBUG -ggdb3 -O0 -fdiagnostics-color=always -fverbose-asm
+endif
+
+build: $(OBJECT_NAME)
+
+$(OBJECT_NAME): $(OBJ)
+	$(info Linking $@)
+ifeq ($(USERSPACE_STATIC_LIBS), 1)
+	$(AR) rcs $(OUTPUT_DIR)$@ $(OBJ)
+else
+	$(CC) -nostdlib -shared -fPIC -fPIE -Wl,-soname,$(OBJECT_NAME) $(SYSROOT) $(OBJ) -o $(OUTPUT_DIR)$@
+endif
+
+%.o: %.c
+	$(info Compiling $<)
+	$(CC) $(CFLAGS) -std=c17 -c $< -o $@
+
+%.o: %.cpp
+	$(info Compiling $<)
+	$(CC) $(CFLAGS) -std=c++20 -c $< -o $@
+
+%.o: %.S
+	$(info Compiling $<)
+	$(AS) -c $< -o $@
+
+clean:
+	rm -f $(OBJ)

Userspace/libc/src/Runtime.c

@@ -0,0 +1,23 @@
+#include <fennix/syscall.h>
+#include <sys/types.h> // For PUBLIC
+
+extern void __libc_init_array(void);
+extern void __libc_fini_array(void);
+
+extern void __libc_init_std(void);
+extern void __libc_fini_std(void);
+
+PUBLIC void __libc_init(void)
+{
+	__libc_init_array();
+	__libc_init_std();
+}
+
+PUBLIC void _exit(int Code)
+{
+	__libc_fini_std();
+	__libc_fini_array();
+	syscall1(sc_exit, (long)Code);
+	while (1)
+		;
+}

Userspace/libc/src/dlfcn.c

@@ -0,0 +1,23 @@
+#include <dlfcn.h>
+
+static char *error = "Not implemented";
+
+__attribute__((weak)) void *dlopen(const char *filename, int flags)
+{
+	return NULL;
+}
+
+__attribute__((weak)) void *dlsym(void *handle, const char *symbol)
+{
+	return NULL;
+}
+
+__attribute__((weak)) int dlclose(void *handle)
+{
+	return -1;
+}
+
+__attribute__((weak)) char *dlerror(void)
+{
+	return error;
+}

Userspace/libc/src/lock.hpp

@@ -0,0 +1,50 @@
+#ifndef __FENNIX_KERNEL_LOCK_H__
+#define __FENNIX_KERNEL_LOCK_H__
+
+#include <types.h>
+
+#ifdef __cplusplus
+/** @brief Please use this macro to create a new lock. */
+class LockClass
+{
+	struct SpinLockData
+	{
+		uint64_t LockData = 0x0;
+		const char *CurrentHolder = "(nul)";
+		const char *AttemptingToGet = "(nul)";
+		uint64_t Count = 0;
+	};
+	void DeadLock(SpinLockData Lock);
+
+private:
+	SpinLockData LockData;
+	bool IsLocked = false;
+
+public:
+	SpinLockData *GetLockData() { return &LockData; }
+	int Lock(const char *FunctionName);
+	int Unlock();
+};
+
+/** @brief Please use this macro to create a new smart lock. */
+class SmartLockClass
+{
+private:
+	LockClass *LockPointer = nullptr;
+
+public:
+	SmartLockClass(LockClass &Lock, const char *FunctionName)
+	{
+		this->LockPointer = &Lock;
+		this->LockPointer->Lock(FunctionName);
+	}
+	~SmartLockClass() { this->LockPointer->Unlock(); }
+};
+
+/** @brief Create a new lock (can be used with SmartCriticalSection). */
+#define NewLock(Name) LockClass Name
+/** @brief Simple lock that is automatically released when the scope ends. */
+#define SmartLock(LockClassName) SmartLockClass CONCAT(lock##_, __COUNTER__)(LockClassName, __FUNCTION__)
+
+#endif // __cplusplus
+#endif // !__FENNIX_KERNEL_LOCK_H__

Userspace/libc/src/main.c

@@ -0,0 +1,5 @@
+/* TODO: Show a message or something */
+int _start()
+{
+	return -1;
+}

Userspace/libc/src/mem/LibAllocImplementation.cpp

@@ -0,0 +1,30 @@
+#include <types.h>
+#include "../lock.hpp"
+
+#include "../../../../Kernel/syscalls.h"
+
+NewLock(liballocLock);
+
+extern "C" int liballoc_lock()
+{
+	return liballocLock.Lock(__FUNCTION__);
+}
+
+extern "C" int liballoc_unlock()
+{
+	return liballocLock.Unlock();
+}
+
+extern "C" void *liballoc_alloc(size_t Pages)
+{
+	return (void *)syscall6(sc_mmap, NULL,
+							Pages * 0x1000,
+							sc_PROT_READ | sc_PROT_WRITE,
+							sc_MAP_ANONYMOUS | sc_MAP_PRIVATE,
+							-1, 0);
+}
+
+extern "C" int liballoc_free(void *Address, size_t Pages)
+{
+	return syscall2(sc_munmap, (uintptr_t)Address, Pages * 0x1000);
+}

Userspace/libc/src/mem/liballoc_1_1.c

@@ -0,0 +1,789 @@
+#include "liballoc_1_1.h"
+
+/**  Durand's Amazing Super Duper Memory functions.  */
+
+#define VERSION "1.1"
+#define ALIGNMENT 16ul // 4ul				///< This is the byte alignment that memory must be allocated on. IMPORTANT for GTK and other stuff.
+
+#define ALIGN_TYPE char					   /// unsigned char[16] /// unsigned short
+#define ALIGN_INFO sizeof(ALIGN_TYPE) * 16 ///< Alignment information is stored right before the pointer. This is the number of bytes of information stored there.
+
+#define USE_CASE1
+#define USE_CASE2
+#define USE_CASE3
+#define USE_CASE4
+#define USE_CASE5
+
+/** This macro will conveniently align our pointer upwards */
+#define ALIGN(ptr)                                       \
+	if (ALIGNMENT > 1)                                   \
+	{                                                    \
+		uintptr_t diff;                                  \
+		ptr = (void *)((uintptr_t)ptr + ALIGN_INFO);     \
+		diff = (uintptr_t)ptr & (ALIGNMENT - 1);         \
+		if (diff != 0)                                   \
+		{                                                \
+			diff = ALIGNMENT - diff;                     \
+			ptr = (void *)((uintptr_t)ptr + diff);       \
+		}                                                \
+		*((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)) = \
+			diff + ALIGN_INFO;                           \
+	}
+
+#define UNALIGN(ptr)                                                     \
+	if (ALIGNMENT > 1)                                                   \
+	{                                                                    \
+		uintptr_t diff = *((ALIGN_TYPE *)((uintptr_t)ptr - ALIGN_INFO)); \
+		if (diff < (ALIGNMENT + ALIGN_INFO))                             \
+		{                                                                \
+			ptr = (void *)((uintptr_t)ptr - diff);                       \
+		}                                                                \
+	}
+
+#define LIBALLOC_MAGIC 0xc001c0de
+#define LIBALLOC_DEAD 0xdeaddead
+
+// #define LIBALLOCDEBUG 1
+#define LIBALLOCINFO 1
+
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+#include <stdio.h>
+#include <stdlib.h>
+// #include <debug.h>
+
+#define FLUSH() fflush(stdout)
+#define atexit(x) atexit(x)
+// #define printf(m, ...) trace(m, ##__VA_ARGS__)
+
+#endif
+
+/** A structure found at the top of all system allocated
+ * memory blocks. It details the usage of the memory block.
+ */
+struct liballoc_major
+{
+	struct liballoc_major *prev;  ///< Linked list information.
+	struct liballoc_major *next;  ///< Linked list information.
+	unsigned int pages;			  ///< The number of pages in the block.
+	unsigned int size;			  ///< The number of pages in the block.
+	unsigned int usage;			  ///< The number of bytes used in the block.
+	struct liballoc_minor *first; ///< A pointer to the first allocated memory in the block.
+};
+
+/** This is a structure found at the beginning of all
+ * sections in a major block which were allocated by a
+ * malloc, calloc, realloc call.
+ */
+struct liballoc_minor
+{
+	struct liballoc_minor *prev;  ///< Linked list information.
+	struct liballoc_minor *next;  ///< Linked list information.
+	struct liballoc_major *block; ///< The owning block. A pointer to the major structure.
+	unsigned int magic;			  ///< A magic number to idenfity correctness.
+	unsigned int size;			  ///< The size of the memory allocated. Could be 1 byte or more.
+	unsigned int req_size;		  ///< The size of memory requested.
+};
+
+static struct liballoc_major *l_memRoot = NULL; ///< The root memory block acquired from the system.
+static struct liballoc_major *l_bestBet = NULL; ///< The major with the most free memory.
+
+static unsigned int l_pageSize = 4096;	   ///< The size of an individual page. Set up in liballoc_init.
+static unsigned int l_pageCount = 16;	   ///< The number of pages to request per chunk. Set up in liballoc_init.
+static unsigned long long l_allocated = 0; ///< Running total of allocated memory.
+static unsigned long long l_inuse = 0;	   ///< Running total of used memory.
+
+static long long l_warningCount = 0;	 ///< Number of warnings encountered
+static long long l_errorCount = 0;		 ///< Number of actual errors
+static long long l_possibleOverruns = 0; ///< Number of possible overruns
+
+// ***********   HELPER FUNCTIONS  *******************************
+
+static void *liballoc_memset(void *s, int c, size_t n)
+{
+	unsigned int i;
+	for (i = 0; i < n; i++)
+		((char *)s)[i] = c;
+
+	return s;
+}
+static void *liballoc_memcpy(void *s1, const void *s2, size_t n)
+{
+	char *cdest;
+	char *csrc;
+	unsigned int *ldest = (unsigned int *)s1;
+	unsigned int *lsrc = (unsigned int *)s2;
+
+	while (n >= sizeof(unsigned int))
+	{
+		*ldest++ = *lsrc++;
+		n -= sizeof(unsigned int);
+	}
+
+	cdest = (char *)ldest;
+	csrc = (char *)lsrc;
+
+	while (n > 0)
+	{
+		*cdest++ = *csrc++;
+		n -= 1;
+	}
+
+	return s1;
+}
+
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+static void liballoc_dump()
+{
+#ifdef LIBALLOCDEBUG
+	struct liballoc_major *maj = l_memRoot;
+	struct liballoc_minor *min = NULL;
+#endif
+
+	printf("liballoc: ------ Memory data ---------------\n");
+	printf("liballoc: System memory allocated: %i bytes\n", l_allocated);
+	printf("liballoc: Memory in used (malloc'ed): %i bytes\n", l_inuse);
+	printf("liballoc: Warning count: %i\n", l_warningCount);
+	printf("liballoc: Error count: %i\n", l_errorCount);
+	printf("liballoc: Possible overruns: %i\n", l_possibleOverruns);
+
+#ifdef LIBALLOCDEBUG
+	while (maj != NULL)
+	{
+		printf("liballoc: %x: total = %i, used = %i\n",
+			   maj,
+			   maj->size,
+			   maj->usage);
+
+		min = maj->first;
+		while (min != NULL)
+		{
+			printf("liballoc:    %x: %i bytes\n",
+				   min,
+				   min->size);
+			min = min->next;
+		}
+
+		maj = maj->next;
+	}
+#endif
+
+	FLUSH();
+}
+#endif
+
+// ***************************************************************
+
+static struct liballoc_major *allocate_new_page(unsigned int size)
+{
+	unsigned int st;
+	struct liballoc_major *maj;
+
+	// This is how much space is required.
+	st = size + sizeof(struct liballoc_major);
+	st += sizeof(struct liballoc_minor);
+
+	// Perfect amount of space?
+	if ((st % l_pageSize) == 0)
+		st = st / (l_pageSize);
+	else
+		st = st / (l_pageSize) + 1;
+	// No, add the buffer.
+
+	// Make sure it's >= the minimum size.
+	if (st < l_pageCount)
+		st = l_pageCount;
+
+	maj = (struct liballoc_major *)liballoc_alloc(st);
+
+	if (maj == NULL)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: liballoc_alloc( %i ) return NULL\n", st);
+		FLUSH();
+#endif
+		return NULL; // uh oh, we ran out of memory.
+	}
+
+	maj->prev = NULL;
+	maj->next = NULL;
+	maj->pages = st;
+	maj->size = st * l_pageSize;
+	maj->usage = sizeof(struct liballoc_major);
+	maj->first = NULL;
+
+	l_allocated += maj->size;
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: Resource allocated %x of %i pages (%i bytes) for %i size.\n", maj, st, maj->size, size);
+
+	printf("liballoc: Total memory usage = %i KB\n", (int)((l_allocated / (1024))));
+	FLUSH();
+#endif
+
+	return maj;
+}
+
+void *PREFIX(malloc)(size_t req_size)
+{
+	int startedBet = 0;
+	unsigned long long bestSize = 0;
+	void *p = NULL;
+	uintptr_t diff;
+	struct liballoc_major *maj;
+	struct liballoc_minor *min;
+	struct liballoc_minor *new_min;
+	unsigned long size = req_size;
+
+	// For alignment, we adjust size so there's enough space to align.
+	if (ALIGNMENT > 1)
+	{
+		size += ALIGNMENT + ALIGN_INFO;
+	}
+	// So, ideally, we really want an alignment of 0 or 1 in order
+	// to save space.
+
+	liballoc_lock();
+
+	if (size == 0)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: alloc( 0 ) called from %x\n",
+			   __builtin_return_address(0));
+		FLUSH();
+#endif
+		liballoc_unlock();
+		return PREFIX(malloc)(1);
+	}
+
+	if (l_memRoot == NULL)
+	{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+#ifdef LIBALLOCDEBUG
+		printf("liballoc: initialization of liballoc " VERSION "\n");
+#endif
+		atexit(liballoc_dump);
+		FLUSH();
+#endif
+
+		// This is the first time we are being used.
+		l_memRoot = allocate_new_page(size);
+		if (l_memRoot == NULL)
+		{
+			liballoc_unlock();
+#ifdef LIBALLOCDEBUG
+			printf("liballoc: initial l_memRoot initialization failed\n", p);
+			FLUSH();
+#endif
+			return NULL;
+		}
+
+#ifdef LIBALLOCDEBUG
+		printf("liballoc: set up first memory major %x\n", l_memRoot);
+		FLUSH();
+#endif
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: %x PREFIX(malloc)( %i ): ",
+		   __builtin_return_address(0),
+		   size);
+	FLUSH();
+#endif
+
+	// Now we need to bounce through every major and find enough space....
+
+	maj = l_memRoot;
+	startedBet = 0;
+
+	// Start at the best bet....
+	if (l_bestBet != NULL)
+	{
+		bestSize = l_bestBet->size - l_bestBet->usage;
+
+		if (bestSize > (size + sizeof(struct liballoc_minor)))
+		{
+			maj = l_bestBet;
+			startedBet = 1;
+		}
+	}
+
+	while (maj != NULL)
+	{
+		diff = maj->size - maj->usage;
+		// free memory in the block
+
+		if (bestSize < diff)
+		{
+			// Hmm.. this one has more memory then our bestBet. Remember!
+			l_bestBet = maj;
+			bestSize = diff;
+		}
+
+#ifdef USE_CASE1
+
+		// CASE 1:  There is not enough space in this major block.
+		if (diff < (size + sizeof(struct liballoc_minor)))
+		{
+#ifdef LIBALLOCDEBUG
+			printf("CASE 1: Insufficient space in block %x\n", maj);
+			FLUSH();
+#endif
+
+			// Another major block next to this one?
+			if (maj->next != NULL)
+			{
+				maj = maj->next; // Hop to that one.
+				continue;
+			}
+
+			if (startedBet == 1) // If we started at the best bet,
+			{					 // let's start all over again.
+				maj = l_memRoot;
+				startedBet = 0;
+				continue;
+			}
+
+			// Create a new major block next to this one and...
+			maj->next = allocate_new_page(size); // next one will be okay.
+			if (maj->next == NULL)
+				break; // no more memory.
+			maj->next->prev = maj;
+			maj = maj->next;
+
+			// .. fall through to CASE 2 ..
+		}
+
+#endif
+
+#ifdef USE_CASE2
+
+		// CASE 2: It's a brand new block.
+		if (maj->first == NULL)
+		{
+			maj->first = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->next = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + sizeof(struct liballoc_minor);
+
+			l_inuse += size;
+
+			p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
+
+			ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+			printf("CASE 2: returning %x\n", p);
+			FLUSH();
+#endif
+			liballoc_unlock(); // release the lock
+			return p;
+		}
+
+#endif
+
+#ifdef USE_CASE3
+
+		// CASE 3: Block in use and enough space at the start of the block.
+		diff = (uintptr_t)(maj->first);
+		diff -= (uintptr_t)maj;
+		diff -= sizeof(struct liballoc_major);
+
+		if (diff >= (size + sizeof(struct liballoc_minor)))
+		{
+			// Yes, space in front. Squeeze in.
+			maj->first->prev = (struct liballoc_minor *)((uintptr_t)maj + sizeof(struct liballoc_major));
+			maj->first->prev->next = maj->first;
+			maj->first = maj->first->prev;
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + sizeof(struct liballoc_minor);
+
+			l_inuse += size;
+
+			p = (void *)((uintptr_t)(maj->first) + sizeof(struct liballoc_minor));
+			ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+			printf("CASE 3: returning %x\n", p);
+			FLUSH();
+#endif
+			liballoc_unlock(); // release the lock
+			return p;
+		}
+
+#endif
+
+#ifdef USE_CASE4
+
+		// CASE 4: There is enough space in this block. But is it contiguous?
+		min = maj->first;
+
+		// Looping within the block now...
+		while (min != NULL)
+		{
+			// CASE 4.1: End of minors in a block. Space from last and end?
+			if (min->next == NULL)
+			{
+				// the rest of this block is free...  is it big enough?
+				diff = (uintptr_t)(maj) + maj->size;
+				diff -= (uintptr_t)min;
+				diff -= sizeof(struct liballoc_minor);
+				diff -= min->size;
+				// minus already existing usage..
+
+				if (diff >= (size + sizeof(struct liballoc_minor)))
+				{
+					// yay....
+					min->next = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
+					min->next->prev = min;
+					min = min->next;
+					min->next = NULL;
+					min->magic = LIBALLOC_MAGIC;
+					min->block = maj;
+					min->size = size;
+					min->req_size = req_size;
+					maj->usage += size + sizeof(struct liballoc_minor);
+
+					l_inuse += size;
+
+					p = (void *)((uintptr_t)min + sizeof(struct liballoc_minor));
+					ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+					printf("CASE 4.1: returning %x\n", p);
+					FLUSH();
+#endif
+					liballoc_unlock(); // release the lock
+					return p;
+				}
+			}
+
+			// CASE 4.2: Is there space between two minors?
+			if (min->next != NULL)
+			{
+				// is the difference between here and next big enough?
+				diff = (uintptr_t)(min->next);
+				diff -= (uintptr_t)min;
+				diff -= sizeof(struct liballoc_minor);
+				diff -= min->size;
+				// minus our existing usage.
+
+				if (diff >= (size + sizeof(struct liballoc_minor)))
+				{
+					// yay......
+					new_min = (struct liballoc_minor *)((uintptr_t)min + sizeof(struct liballoc_minor) + min->size);
+
+					new_min->magic = LIBALLOC_MAGIC;
+					new_min->next = min->next;
+					new_min->prev = min;
+					new_min->size = size;
+					new_min->req_size = req_size;
+					new_min->block = maj;
+					min->next->prev = new_min;
+					min->next = new_min;
+					maj->usage += size + sizeof(struct liballoc_minor);
+
+					l_inuse += size;
+
+					p = (void *)((uintptr_t)new_min + sizeof(struct liballoc_minor));
+					ALIGN(p);
+
+#ifdef LIBALLOCDEBUG
+					printf("CASE 4.2: returning %x\n", p);
+					FLUSH();
+#endif
+
+					liballoc_unlock(); // release the lock
+					return p;
+				}
+			} // min->next != NULL
+
+			min = min->next;
+		} // while min != NULL ...
+
+#endif
+
+#ifdef USE_CASE5
+
+		// CASE 5: Block full! Ensure next block and loop.
+		if (maj->next == NULL)
+		{
+#ifdef LIBALLOCDEBUG
+			printf("CASE 5: block full\n");
+			FLUSH();
+#endif
+
+			if (startedBet == 1)
+			{
+				maj = l_memRoot;
+				startedBet = 0;
+				continue;
+			}
+
+			// we've run out. we need more...
+			maj->next = allocate_new_page(size); // next one guaranteed to be okay
+			if (maj->next == NULL)
+				break; //  uh oh,  no more memory.....
+			maj->next->prev = maj;
+		}
+
+#endif
+
+		maj = maj->next;
+	} // while (maj != NULL)
+
+	liballoc_unlock(); // release the lock
+
+#ifdef LIBALLOCDEBUG
+	printf("All cases exhausted. No memory available.\n");
+	FLUSH();
+#endif
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+	printf("liballoc: WARNING: PREFIX(malloc)( %i ) returning NULL.\n", size);
+	liballoc_dump();
+	FLUSH();
+#endif
+	return NULL;
+}
+
+void PREFIX(free)(void *ptr)
+{
+	struct liballoc_minor *min;
+	struct liballoc_major *maj;
+
+	if (ptr == NULL)
+	{
+		l_warningCount += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+		printf("liballoc: WARNING: PREFIX(free)( NULL ) called from %x\n",
+			   __builtin_return_address(0));
+		FLUSH();
+#endif
+		return;
+	}
+
+	UNALIGN(ptr);
+
+	liballoc_lock(); // lockit
+
+	min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
+
+	if (min->magic != LIBALLOC_MAGIC)
+	{
+		l_errorCount += 1;
+
+		// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
+		if (
+			((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
+			((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
+			((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
+		{
+			l_possibleOverruns += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Possible 1-3 byte overrun for magic %x != %x\n",
+				   min->magic,
+				   LIBALLOC_MAGIC);
+			FLUSH();
+#endif
+		}
+
+		if (min->magic == LIBALLOC_DEAD)
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: multiple PREFIX(free)() attempt on %x from %x.\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+		else
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Bad PREFIX(free)( %x ) called from %x\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+
+		// being lied to...
+		liballoc_unlock(); // release the lock
+		return;
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("liballoc: %x PREFIX(free)( %x ): ",
+		   __builtin_return_address(0),
+		   ptr);
+	FLUSH();
+#endif
+
+	maj = min->block;
+
+	l_inuse -= min->size;
+
+	maj->usage -= (min->size + sizeof(struct liballoc_minor));
+	min->magic = LIBALLOC_DEAD; // No mojo.
+
+	if (min->next != NULL)
+		min->next->prev = min->prev;
+	if (min->prev != NULL)
+		min->prev->next = min->next;
+
+	if (min->prev == NULL)
+		maj->first = min->next;
+	// Might empty the block. This was the first
+	// minor.
+
+	// We need to clean up after the majors now....
+
+	if (maj->first == NULL) // Block completely unused.
+	{
+		if (l_memRoot == maj)
+			l_memRoot = maj->next;
+		if (l_bestBet == maj)
+			l_bestBet = NULL;
+		if (maj->prev != NULL)
+			maj->prev->next = maj->next;
+		if (maj->next != NULL)
+			maj->next->prev = maj->prev;
+		l_allocated -= maj->size;
+
+		liballoc_free(maj, maj->pages);
+	}
+	else
+	{
+		if (l_bestBet != NULL)
+		{
+			int bestSize = l_bestBet->size - l_bestBet->usage;
+			int majSize = maj->size - maj->usage;
+
+			if (majSize > bestSize)
+				l_bestBet = maj;
+		}
+	}
+
+#ifdef LIBALLOCDEBUG
+	printf("OK\n");
+	FLUSH();
+#endif
+
+	liballoc_unlock(); // release the lock
+}
+
+void *PREFIX(calloc)(size_t nobj, size_t size)
+{
+	int real_size;
+	void *p;
+
+	real_size = nobj * size;
+
+	p = PREFIX(malloc)(real_size);
+
+	liballoc_memset(p, 0, real_size);
+
+	return p;
+}
+
+void *PREFIX(realloc)(void *p, size_t size)
+{
+	void *ptr;
+	struct liballoc_minor *min;
+	unsigned int real_size;
+
+	// Honour the case of size == 0 => free old and return NULL
+	if (size == 0)
+	{
+		PREFIX(free)
+		(p);
+		return NULL;
+	}
+
+	// In the case of a NULL pointer, return a simple malloc.
+	if (p == NULL)
+		return PREFIX(malloc)(size);
+
+	// Unalign the pointer if required.
+	ptr = p;
+	UNALIGN(ptr);
+
+	liballoc_lock(); // lockit
+
+	min = (struct liballoc_minor *)((uintptr_t)ptr - sizeof(struct liballoc_minor));
+
+	// Ensure it is a valid structure.
+	if (min->magic != LIBALLOC_MAGIC)
+	{
+		l_errorCount += 1;
+
+		// Check for overrun errors. For all bytes of LIBALLOC_MAGIC
+		if (
+			((min->magic & 0xFFFFFF) == (LIBALLOC_MAGIC & 0xFFFFFF)) ||
+			((min->magic & 0xFFFF) == (LIBALLOC_MAGIC & 0xFFFF)) ||
+			((min->magic & 0xFF) == (LIBALLOC_MAGIC & 0xFF)))
+		{
+			l_possibleOverruns += 1;
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Possible 1-3 byte overrun for magic %x != %x\n",
+				   min->magic,
+				   LIBALLOC_MAGIC);
+			FLUSH();
+#endif
+		}
+
+		if (min->magic == LIBALLOC_DEAD)
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: multiple PREFIX(free)() attempt on %x from %x.\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+		else
+		{
+#if defined LIBALLOCDEBUG || defined LIBALLOCINFO
+			printf("liballoc: ERROR: Bad PREFIX(free)( %x ) called from %x\n",
+				   ptr,
+				   __builtin_return_address(0));
+			FLUSH();
+#endif
+		}
+
+		// being lied to...
+		liballoc_unlock(); // release the lock
+		return NULL;
+	}
+
+	// Definitely a memory block.
+
+	real_size = min->req_size;
+
+	if (real_size >= size)
+	{
+		min->req_size = size;
+		liballoc_unlock();
+		return p;
+	}
+
+	liballoc_unlock();
+
+	// If we got here then we're reallocating to a block bigger than us.
+	ptr = PREFIX(malloc)(size); // We need to allocate new memory
+	liballoc_memcpy(ptr, p, real_size);
+	PREFIX(free)
+	(p);
+
+	return ptr;
+}

Userspace/libc/src/mem/liballoc_1_1.h

@@ -0,0 +1,74 @@
+#ifndef _LIBALLOC_H
+#define _LIBALLOC_H
+
+#include <types.h>
+
+/** \defgroup ALLOCHOOKS liballoc hooks
+ *
+ * These are the OS specific functions which need to
+ * be implemented on any platform that the library
+ * is expected to work on.
+ */
+
+/** @{ */
+
+// If we are told to not define our own size_t, then we skip the define.
+// #define _HAVE_UINTPTR_T
+// typedef	unsigned long	uintptr_t;
+
+// This lets you prefix malloc and friends
+#define PREFIX(func) __##func
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    /** This function is supposed to lock the memory data structures. It
+     * could be as simple as disabling interrupts or acquiring a spinlock.
+     * It's up to you to decide.
+     *
+     * \return 0 if the lock was acquired successfully. Anything else is
+     * failure.
+     */
+    extern int liballoc_lock();
+
+    /** This function unlocks what was previously locked by the liballoc_lock
+     * function.  If it disabled interrupts, it enables interrupts. If it
+     * had acquiried a spinlock, it releases the spinlock. etc.
+     *
+     * \return 0 if the lock was successfully released.
+     */
+    extern int liballoc_unlock();
+
+    /** This is the hook into the local system which allocates pages. It
+     * accepts an integer parameter which is the number of pages
+     * required.  The page size was set up in the liballoc_init function.
+     *
+     * \return NULL if the pages were not allocated.
+     * \return A pointer to the allocated memory.
+     */
+    extern void *liballoc_alloc(size_t);
+
+    /** This frees previously allocated memory. The void* parameter passed
+     * to the function is the exact same value returned from a previous
+     * liballoc_alloc call.
+     *
+     * The integer value is the number of pages to free.
+     *
+     * \return 0 if the memory was successfully freed.
+     */
+    extern int liballoc_free(void *, size_t);
+
+    extern void *PREFIX(malloc)(size_t);          ///< The standard function.
+    extern void *PREFIX(realloc)(void *, size_t); ///< The standard function.
+    extern void *PREFIX(calloc)(size_t, size_t);  ///< The standard function.
+    extern void PREFIX(free)(void *);             ///< The standard function.
+
+#ifdef __cplusplus
+}
+#endif
+
+/** @} */
+
+#endif

Userspace/libc/src/print/printf.h

@@ -0,0 +1,194 @@
+/**
+ * @author (c) Eyal Rozenberg <eyalroz1@gmx.com>
+ *             2021-2022, Haifa, Palestine/Israel
+ * @author (c) Marco Paland (info@paland.com)
+ *             2014-2019, PALANDesign Hannover, Germany
+ *
+ * @note Others have made smaller contributions to this file: see the
+ * contributors page at https://github.com/eyalroz/printf/graphs/contributors
+ * or ask one of the authors.
+ *
+ * @brief Small stand-alone implementation of the printf family of functions
+ * (`(v)printf`, `(v)s(n)printf` etc., geared towards use on embedded systems with
+ * a very limited resources.
+ *
+ * @note the implementations are thread-safe; re-entrant; use no functions from
+ * the standard library; and do not dynamically allocate any memory.
+ *
+ * @license The MIT License (MIT)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef PRINTF_H_
+#define PRINTF_H_
+
+#include <types.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __GNUC__
+#define ATTR_PRINTF(one_based_format_index, first_arg) \
+    __attribute__((format(__printf__, (one_based_format_index), (first_arg))))
+#define ATTR_VPRINTF(one_based_format_index) ATTR_PRINTF((one_based_format_index), 0)
+#else
+#define ATTR_PRINTF((one_based_format_index), (first_arg))
+#define ATTR_VPRINTF(one_based_format_index)
+#endif
+
+#ifndef PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
+#define PRINTF_ALIAS_STANDARD_FUNCTION_NAMES 0
+#endif
+
+#if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
+#define printf_ printf
+#define sprintf_ sprintf
+#define vsprintf_ vsprintf
+#define snprintf_ snprintf
+#define vsnprintf_ vsnprintf
+#define vprintf_ vprintf
+#endif
+
+// If you want to include this implementation file directly rather than
+// link against, this will let you control the functions' visibility,
+// e.g. make them static so as not to clash with other objects also
+// using them.
+#ifndef PRINTF_VISIBILITY
+#define PRINTF_VISIBILITY __attribute__((visibility("default")))
+#endif
+
+    /**
+     * Prints/send a single character to some opaque output entity
+     *
+     * @note This function is not implemented by the library, only declared; you must provide an
+     * implementation if you wish to use the @ref printf / @ref vprintf function (and possibly
+     * for linking against the library, if your toolchain does not support discarding unused functions)
+     *
+     * @note The output could be as simple as a wrapper for the `write()` system call on a Unix-like
+     * system, or even libc's @ref putchar , for replicating actual functionality of libc's @ref printf
+     * function; but on an embedded system it may involve interaction with a special output device,
+     * like a UART, etc.
+     *
+     * @note in libc's @ref putchar, the parameter type is an int; this was intended to support the
+     * representation of either a proper character or EOF in a variable - but this is really not
+     * meaningful to pass into @ref putchar and is discouraged today. See further discussion in:
+     * @link https://stackoverflow.com/q/17452847/1593077
+     *
+     * @param c the single character to print
+     */
+    PRINTF_VISIBILITY
+    int putchar(int c);
+
+    /**
+     * An implementation of the C standard's printf/vprintf
+     *
+     * @note you must implement a @ref putchar_ function for using this function - it invokes @ref putchar_
+     * rather than directly performing any I/O (which insulates it from any dependence on the operating system
+     * and external libraries).
+     *
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each %-specifier in @p format string
+     * @return The number of characters written into @p s, not counting the terminating null character
+     */
+    ///@{
+    PRINTF_VISIBILITY
+    int printf(const char *format, ...) ATTR_PRINTF(1, 2);
+    PRINTF_VISIBILITY
+    int vprintf(const char *format, va_list arg) ATTR_VPRINTF(1);
+    ///@}
+
+    /**
+     * An implementation of the C standard's sprintf/vsprintf
+     *
+     * @note For security considerations (the potential for exceeding the buffer bounds), please consider using
+     * the size-constrained variant, @ref snprintf / @ref vsnprintf , instead.
+     *
+     * @param s An array in which to store the formatted string. It must be large enough to fit the formatted
+     * output!
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each specifier in @p format
+     * @return The number of characters written into @p s, not counting the terminating null character
+     */
+    ///@{
+    PRINTF_VISIBILITY
+    int sprintf(char *s, const char *format, ...) ATTR_PRINTF(2, 3);
+    PRINTF_VISIBILITY
+    int vsprintf(char *s, const char *format, va_list arg) ATTR_VPRINTF(2);
+    ///@}
+
+    /**
+     * An implementation of the C standard's snprintf/vsnprintf
+     *
+     * @param s An array in which to store the formatted string. It must be large enough to fit either the
+     * entire formatted output, or at least @p n characters. Alternatively, it can be NULL, in which case
+     * nothing will be printed, and only the number of characters which _could_ have been printed is
+     * tallied and returned.
+     * @param n The maximum number of characters to write to the array, including a terminating null character
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each specifier in @p format
+     * @return The number of characters that COULD have been written into @p s, not counting the terminating
+     *         null character. A value equal or larger than @p n indicates truncation. Only when the returned value
+     *         is non-negative and less than @p n, the null-terminated string has been fully and successfully printed.
+     */
+    ///@{
+    PRINTF_VISIBILITY
+    int snprintf(char *s, size_t count, const char *format, ...) ATTR_PRINTF(3, 4);
+    PRINTF_VISIBILITY
+    int vsnprintf(char *s, size_t count, const char *format, va_list arg) ATTR_VPRINTF(3);
+    ///@}
+
+    /**
+     * printf/vprintf with user-specified output function
+     *
+     * An alternative to @ref printf_, in which the output function is specified dynamically
+     * (rather than @ref putchar_ being used)
+     *
+     * @param out An output function which takes one character and a type-erased additional parameters
+     * @param extra_arg The type-erased argument to pass to the output function @p out with each call
+     * @param format A string specifying the format of the output, with %-marked specifiers of how to interpret
+     * additional arguments.
+     * @param arg Additional arguments to the function, one for each specifier in @p format
+     * @return The number of characters for which the output f unction was invoked, not counting the terminating null character
+     *
+     */
+    PRINTF_VISIBILITY
+    int fctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, ...) ATTR_PRINTF(3, 4);
+    PRINTF_VISIBILITY
+    int vfctprintf(void (*out)(char c, void *extra_arg), void *extra_arg, const char *format, va_list arg) ATTR_VPRINTF(3);
+
+#if PRINTF_ALIAS_STANDARD_FUNCTION_NAMES
+#undef printf_
+#undef sprintf_
+#undef vsprintf_
+#undef snprintf_
+#undef vsnprintf_
+#undef vprintf_
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PRINTF_H_

Userspace/libc/src/setjmp.c

@@ -0,0 +1,11 @@
+#include <setjmp.h>
+
+PUBLIC int setjmp(jmp_buf env)
+{
+	return 0;
+}
+
+PUBLIC __attribute__((noreturn)) void longjmp(jmp_buf env, int value)
+{
+	_exit(value);
+}

Userspace/libc/src/std/ctype.c

@@ -0,0 +1,29 @@
+#include <ctype.h>
+
+#include <sys/types.h> // For PUBLIC
+
+PUBLIC int tolower(int c)
+{
+    if (c >= 'A' && c <= 'Z')
+    {
+        c -= 'A';
+        c += 'a';
+    }
+
+    return c;
+}
+
+PUBLIC int toupper(int c)
+{
+    if (c >= 'a' && c <= 'z')
+    {
+        c -= 'a';
+        c += 'A';
+    }
+    return c;
+}
+
+PUBLIC int isspace(int c)
+{
+    return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f' || c == '\v';
+}

Userspace/libc/src/std/errno.c

@@ -0,0 +1,10 @@
+#include <errno.h>
+
+#include <sys/types.h> // For PUBLIC
+
+int __local_stub_errno = 0;
+
+PUBLIC int *__errno_location(void)
+{
+    return &__local_stub_errno;
+}

Userspace/libc/src/std/io/file.c

@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#include <fennix/syscall.h>
+#include <sys/types.h> // For PUBLIC
+
+PUBLIC FILE *stdin = NULL;
+PUBLIC FILE *stdout = NULL;
+PUBLIC FILE *stderr = NULL;
+
+PUBLIC FILE *freopen(const char *filename, const char *mode, FILE *stream)
+{
+	errno = ENOSYS;
+	return NULL;
+}
+
+PUBLIC FILE *fopen(const char *filename, const char *mode)
+{
+	int fd = syscall2(sc_open, (uint64_t)filename, (uint64_t)mode);
+	if (fd < 0)
+		return NULL;
+
+	FILE *FilePtr = malloc(sizeof(FILE));
+	FilePtr->_fileno = fd;
+	return FilePtr;
+}
+
+PUBLIC size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	if (ptr == NULL || stream == NULL || size == 0 || nmemb == 0)
+	{
+		errno = EINVAL;
+		return 0;
+	}
+
+	syscall3(sc_lseek, stream->_fileno, stream->_offset, SEEK_SET);
+	return syscall3(sc_read, (uint64_t)stream->_fileno, (uint64_t)ptr, size * nmemb);
+}
+
+PUBLIC size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+	if (ptr == NULL || stream == NULL || size == 0 || nmemb == 0)
+	{
+		errno = EINVAL;
+		return 0;
+	}
+
+	syscall3(sc_lseek, stream->_fileno, stream->_offset, SEEK_SET);
+	return syscall3(sc_write, (uint64_t)stream->_fileno, (uint64_t)ptr, size * nmemb);
+}
+
+PUBLIC int fclose(FILE *fp)
+{
+	if (fp == NULL)
+	{
+		errno = EINVAL;
+		return EOF;
+	}
+
+	return syscall1(sc_close, fp->_fileno);
+}
+
+PUBLIC off_t fseek(FILE *stream, off_t offset, int whence)
+{
+	if (stream == NULL || whence < 0 || whence > 2)
+	{
+		errno = EINVAL;
+		return -1;
+	}
+
+	off_t new_offset = syscall3(sc_lseek, stream->_fileno, offset, whence);
+	if (new_offset < 0)
+		return -1;
+	stream->_offset = new_offset;
+	return new_offset;
+}
+
+PUBLIC long ftell(FILE *stream)
+{
+	return stream->_offset;
+}
+
+PUBLIC int fflush(FILE *stream)
+{
+	if (stream == NULL)
+	{
+		errno = EINVAL;
+		return EOF;
+	}
+
+	errno = ENOSYS;
+	return EOF;
+}
+
+PUBLIC int fprintf(FILE *stream, const char *format, ...)
+{
+	if (stream == NULL || format == NULL)
+	{
+		errno = EINVAL;
+		return -1;
+	}
+
+	va_list args;
+	va_start(args, format);
+	const int ret = vfprintf(stream, format, args);
+	va_end(args);
+	return ret;
+}
+
+PUBLIC void setbuf(FILE *stream, char *buf)
+{
+}
+
+PUBLIC int vfprintf(FILE *stream, const char *format, va_list arg)
+{
+	return 0;
+}
+
+PUBLIC int vsscanf(const char *s, const char *format, va_list arg)
+{
+}
+
+PUBLIC int sscanf(const char *s, const char *format, ...)
+{
+	va_list args;
+	va_start(args, format);
+	const int ret = vsscanf(s, format, args);
+	va_end(args);
+	return ret;
+}

Userspace/libc/src/std/io/get.c

@@ -0,0 +1,9 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <fennix/syscall.h>
+
+#include <sys/types.h> // For PUBLIC
+
+PUBLIC int fgetc(FILE *stream)
+{
+}

Userspace/libc/src/std/io/put.c

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdarg.h>
+#include <fennix/syscall.h>
+
+#include <sys/types.h> // For PUBLIC
+
+PUBLIC int fputc(int c, FILE *stream)
+{
+	// FIXME
+	// if (stream == NULL)
+	// {
+	//     errno = EBADF;
+	//     return EOF;
+	// }
+	char str[2] = {c, '\0'};
+	// return syscall3(sys_KernelCTL, KCTL_PRINT, str, 0);
+}
+
+PUBLIC int putc(int c, FILE *stream) { return fputc(c, stream); }
+
+PUBLIC int fputs(const char *s, FILE *stream)
+{
+	for (int i = 0; s[i] != '\0'; i++)
+		fputc(s[i], stream);
+}
+
+PUBLIC int puts(const char *s)
+{
+	for (int i = 0; s[i] != '\0'; i++)
+		fputc(s[i], stdout);
+}
+
+PUBLIC int putchar(int c) { return fputc(c, stdout); }
+PUBLIC void perror(const char *s) { fputs(s, stderr); }

Userspace/libc/src/std/lib.c

@@ -0,0 +1,87 @@
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <fennix/syscall.h>
+
+#include "../mem/liballoc_1_1.h"
+
+PUBLIC void abort(void)
+{
+	syscall1(sc_exit, -0xAB057);
+	while (1)
+		;
+}
+
+PUBLIC int atexit(void (*function)(void))
+{
+	return 1;
+}
+
+PUBLIC void exit(int status)
+{
+	_exit(status);
+}
+
+PUBLIC int atoi(const char *nptr)
+{
+	uint64_t Length = strlen((char *)nptr);
+	if (nptr)
+		while (nptr[Length] != '\0')
+			++Length;
+	uint64_t OutBuffer = 0;
+	uint64_t Power = 1;
+	for (uint64_t i = Length; i > 0; --i)
+	{
+		OutBuffer += (nptr[i - 1] - 48) * Power;
+		Power *= 10;
+	}
+	return OutBuffer;
+}
+
+PUBLIC char **environ = NULL;
+
+PUBLIC char *getenv(const char *name)
+{
+	char **env = environ;
+	if (env == NULL)
+		return NULL;
+	size_t len = strlen(name);
+	while (*env != NULL)
+	{
+		if ((strncmp(*env, name, len) == 0) && ((*env)[len] == '='))
+			return &(*env)[len + 1];
+		++env;
+	}
+}
+
+PUBLIC void *malloc(size_t Size) { return PREFIX(malloc)(Size); }
+PUBLIC void *realloc(void *Address, size_t Size) { return PREFIX(realloc)(Address, Size); }
+PUBLIC void *calloc(size_t Count, size_t Size) { return PREFIX(calloc)(Count, Size); }
+PUBLIC void free(void *Address)
+{
+	PREFIX(free)
+	(Address);
+}
+
+PUBLIC int system(const char *command)
+{
+	return -1;
+}
+
+PUBLIC double atof(const char *nptr)
+{
+	// FIXME: This is a very bad implementation of atof.
+	uint64_t Length = strlen((char *)nptr);
+	if (nptr)
+		while (nptr[Length] != '\0')
+			++Length;
+	double OutBuffer = 0;
+	double Power = 1;
+	for (uint64_t i = Length; i > 0; --i)
+	{
+		OutBuffer += (nptr[i - 1] - 48) * Power;
+		Power *= 10;
+	}
+	return OutBuffer;
+}

Userspace/libc/src/std/spawn.c

@@ -0,0 +1,17 @@
+#include <spawn.h>
+
+int posix_spawn(pid_t *pid, const char *path,
+				const posix_spawn_file_actions_t *file_actions,
+				const posix_spawnattr_t *attrp,
+				char *const argv[],
+				char *const envp[])
+{
+}
+
+int posix_spawnp(pid_t *pid, const char *file,
+				 const posix_spawn_file_actions_t *file_actions,
+				 const posix_spawnattr_t *attrp,
+				 char *const argv[],
+				 char *const envp[])
+{
+}

Userspace/libc/src/std/std_init.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+#include "../../../Kernel/syscalls.h"
+
+void __libc_init_std(void)
+{
+	/* FIXME: Temporal workaround */
+	// int IsCritical = syscall1(_KernelCTL, 6 /* KCTL_IS_CRITICAL */);
+}
+
+void __libc_fini_std(void)
+{
+}

Userspace/libc/src/std/string/memop.c

@@ -0,0 +1,346 @@
+#include <stddef.h>
+
+#include <sys/types.h> // For PUBLIC
+
+/* Some of the functions are from musl library */
+/* https://www.musl-libc.org/ */
+/*
+Copyright © 2005-2020 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+PUBLIC void *memcpy(void *dest, const void *src, size_t n)
+{
+	unsigned char *d = dest;
+	const unsigned char *s = src;
+
+#ifdef __GNUC__
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define LS >>
+#define RS <<
+#else
+#define LS <<
+#define RS >>
+#endif
+
+	typedef uint32_t __attribute__((__may_alias__)) u32;
+	uint32_t w, x;
+
+	for (; (uintptr_t)s % 4 && n; n--)
+		*d++ = *s++;
+
+	if ((uintptr_t)d % 4 == 0)
+	{
+		for (; n >= 16; s += 16, d += 16, n -= 16)
+		{
+			*(u32 *)(d + 0) = *(u32 *)(s + 0);
+			*(u32 *)(d + 4) = *(u32 *)(s + 4);
+			*(u32 *)(d + 8) = *(u32 *)(s + 8);
+			*(u32 *)(d + 12) = *(u32 *)(s + 12);
+		}
+		if (n & 8)
+		{
+			*(u32 *)(d + 0) = *(u32 *)(s + 0);
+			*(u32 *)(d + 4) = *(u32 *)(s + 4);
+			d += 8;
+			s += 8;
+		}
+		if (n & 4)
+		{
+			*(u32 *)(d + 0) = *(u32 *)(s + 0);
+			d += 4;
+			s += 4;
+		}
+		if (n & 2)
+		{
+			*d++ = *s++;
+			*d++ = *s++;
+		}
+		if (n & 1)
+		{
+			*d = *s;
+		}
+		return dest;
+	}
+
+	if (n >= 32)
+	{
+		switch ((uintptr_t)d % 4)
+		{
+		case 1:
+		{
+			w = *(u32 *)s;
+			*d++ = *s++;
+			*d++ = *s++;
+			*d++ = *s++;
+			n -= 3;
+			for (; n >= 17; s += 16, d += 16, n -= 16)
+			{
+				x = *(u32 *)(s + 1);
+				*(u32 *)(d + 0) = (w LS 24) | (x RS 8);
+				w = *(u32 *)(s + 5);
+				*(u32 *)(d + 4) = (x LS 24) | (w RS 8);
+				x = *(u32 *)(s + 9);
+				*(u32 *)(d + 8) = (w LS 24) | (x RS 8);
+				w = *(u32 *)(s + 13);
+				*(u32 *)(d + 12) = (x LS 24) | (w RS 8);
+			}
+			break;
+		}
+		case 2:
+		{
+			w = *(u32 *)s;
+			*d++ = *s++;
+			*d++ = *s++;
+			n -= 2;
+			for (; n >= 18; s += 16, d += 16, n -= 16)
+			{
+				x = *(u32 *)(s + 2);
+				*(u32 *)(d + 0) = (w LS 16) | (x RS 16);
+				w = *(u32 *)(s + 6);
+				*(u32 *)(d + 4) = (x LS 16) | (w RS 16);
+				x = *(u32 *)(s + 10);
+				*(u32 *)(d + 8) = (w LS 16) | (x RS 16);
+				w = *(u32 *)(s + 14);
+				*(u32 *)(d + 12) = (x LS 16) | (w RS 16);
+			}
+			break;
+		}
+		case 3:
+		{
+			w = *(u32 *)s;
+			*d++ = *s++;
+			n -= 1;
+			for (; n >= 19; s += 16, d += 16, n -= 16)
+			{
+				x = *(u32 *)(s + 3);
+				*(u32 *)(d + 0) = (w LS 8) | (x RS 24);
+				w = *(u32 *)(s + 7);
+				*(u32 *)(d + 4) = (x LS 8) | (w RS 24);
+				x = *(u32 *)(s + 11);
+				*(u32 *)(d + 8) = (w LS 8) | (x RS 24);
+				w = *(u32 *)(s + 15);
+				*(u32 *)(d + 12) = (x LS 8) | (w RS 24);
+			}
+			break;
+		}
+		default:
+			break;
+		}
+	}
+
+	if (n & 16)
+	{
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+	}
+
+	if (n & 8)
+	{
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+	}
+
+	if (n & 4)
+	{
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+		*d++ = *s++;
+	}
+
+	if (n & 2)
+	{
+		*d++ = *s++;
+		*d++ = *s++;
+	}
+
+	if (n & 1)
+	{
+		*d = *s;
+	}
+	return dest;
+#endif
+
+	for (; n; n--)
+		*d++ = *s++;
+	return dest;
+}
+
+PUBLIC void *memset(void *dest, int c, size_t n)
+{
+	unsigned char *s = dest;
+	size_t k;
+
+	if (!n)
+		return dest;
+
+	s[0] = c;
+	s[n - 1] = c;
+
+	if (n <= 2)
+		return dest;
+
+	s[1] = c;
+	s[2] = c;
+	s[n - 2] = c;
+	s[n - 3] = c;
+
+	if (n <= 6)
+		return dest;
+
+	s[3] = c;
+	s[n - 4] = c;
+
+	if (n <= 8)
+		return dest;
+
+	k = -(uintptr_t)s & 3;
+	s += k;
+	n -= k;
+	n &= -4;
+
+#ifdef __GNUC__
+	typedef uint32_t __attribute__((__may_alias__)) u32;
+	typedef uint64_t __attribute__((__may_alias__)) u64;
+
+	u32 c32 = ((u32)-1) / 255 * (unsigned char)c;
+	*(u32 *)(s + 0) = c32;
+	*(u32 *)(s + n - 4) = c32;
+
+	if (n <= 8)
+		return dest;
+
+	*(u32 *)(s + 4) = c32;
+	*(u32 *)(s + 8) = c32;
+	*(u32 *)(s + n - 12) = c32;
+	*(u32 *)(s + n - 8) = c32;
+
+	if (n <= 24)
+		return dest;
+
+	*(u32 *)(s + 12) = c32;
+	*(u32 *)(s + 16) = c32;
+	*(u32 *)(s + 20) = c32;
+	*(u32 *)(s + 24) = c32;
+	*(u32 *)(s + n - 28) = c32;
+	*(u32 *)(s + n - 24) = c32;
+	*(u32 *)(s + n - 20) = c32;
+	*(u32 *)(s + n - 16) = c32;
+
+	k = 24 + ((uintptr_t)s & 4);
+	s += k;
+	n -= k;
+
+	u64 c64 = c32 | ((u64)c32 << 32);
+	for (; n >= 32; n -= 32, s += 32)
+	{
+		*(u64 *)(s + 0) = c64;
+		*(u64 *)(s + 8) = c64;
+		*(u64 *)(s + 16) = c64;
+		*(u64 *)(s + 24) = c64;
+	}
+#else
+	for (; n; n--, s++)
+		*s = c;
+#endif
+
+	return dest;
+}
+
+PUBLIC void *memmove(void *dest, const void *src, size_t n)
+{
+#ifdef __GNUC__
+	typedef __attribute__((__may_alias__)) size_t WT;
+#define WS (sizeof(WT))
+#endif
+
+	char *d = dest;
+	const char *s = src;
+
+	if (d == s)
+		return d;
+
+	if ((uintptr_t)s - (uintptr_t)d - n <= -2 * n)
+		return memcpy(d, s, n);
+
+	if (d < s)
+	{
+#ifdef __GNUC__
+		if ((uintptr_t)s % WS == (uintptr_t)d % WS)
+		{
+			while ((uintptr_t)d % WS)
+			{
+				if (!n--)
+					return dest;
+
+				*d++ = *s++;
+			}
+			for (; n >= WS; n -= WS, d += WS, s += WS)
+				*(WT *)d = *(WT *)s;
+		}
+#endif
+		for (; n; n--)
+			*d++ = *s++;
+	}
+	else
+	{
+#ifdef __GNUC__
+		if ((uintptr_t)s % WS == (uintptr_t)d % WS)
+		{
+			while ((uintptr_t)(d + n) % WS)
+			{
+				if (!n--)
+					return dest;
+
+				d[n] = s[n];
+			}
+			while (n >= WS)
+				n -= WS, *(WT *)(d + n) = *(WT *)(s + n);
+		}
+#endif
+		while (n)
+			n--, d[n] = s[n];
+	}
+
+	return dest;
+}

Userspace/libc/src/std/string/string.c

@@ -0,0 +1,125 @@
+#include <string.h>
+
+#include "../../mem/liballoc_1_1.h"
+
+PUBLIC size_t strlen(const char *str)
+{
+	long unsigned i = 0;
+	if (str)
+		while (str[i] != '\0')
+			++i;
+	return i;
+}
+
+PUBLIC int strcmp(const char *l, const char *r)
+{
+	for (; *l == *r && *l; l++, r++)
+		;
+	return *(unsigned char *)l - *(unsigned char *)r;
+}
+
+PUBLIC int strncmp(const char *s1, const char *s2, size_t n)
+{
+	for (size_t i = 0; i < n; i++)
+	{
+		char c1 = s1[i], c2 = s2[i];
+		if (c1 != c2)
+			return c1 - c2;
+		if (!c1)
+			return 0;
+	}
+	return 0;
+}
+
+PUBLIC int strcasecmp(const char *s1, const char *s2)
+{
+	const unsigned char *p1 = (const unsigned char *)s1;
+	const unsigned char *p2 = (const unsigned char *)s2;
+	int result;
+	if (p1 == p2)
+		return 0;
+	while ((result = tolower(*p1) - tolower(*p2++)) == 0)
+		if (*p1++ == '\0')
+			break;
+	return result;
+}
+
+PUBLIC int strncasecmp(const char *string1, const char *string2, size_t count)
+{
+	if (count)
+	{
+		const unsigned char *s1 = (const unsigned char *)string1;
+		const unsigned char *s2 = (const unsigned char *)string2;
+		int result;
+		do
+		{
+			if ((result = tolower(*s1) - tolower(*s2++)) != 0 || !*s1++)
+				break;
+		} while (--count);
+		return result;
+	}
+	return 0;
+}
+
+PUBLIC char *strstr(const char *haystack, const char *needle)
+{
+	const char *a = haystack, *b = needle;
+	while (1)
+	{
+		if (!*b)
+			return (char *)haystack;
+		if (!*a)
+			return NULL;
+		if (*a++ != *b++)
+		{
+			a = ++haystack;
+			b = needle;
+		}
+	}
+}
+
+PUBLIC char *strncpy(char *destination, const char *source, unsigned long num)
+{
+	if (destination == NULL)
+		return NULL;
+	char *ptr = destination;
+	while (*source && num--)
+	{
+		*destination = *source;
+		destination++;
+		source++;
+	}
+	*destination = '\0';
+	return ptr;
+}
+
+PUBLIC char *strdup(const char *s)
+{
+	char *buf = (char *)__malloc(strlen((char *)s) + 1);
+	strncpy(buf, s, strlen(s) + 1);
+	return buf;
+}
+
+PUBLIC char *strchr(char const *s, int c)
+{
+	size_t len = strlen(s);
+	for (size_t i = 0; i < len; i++)
+		if (s[i] == c)
+			return (char *)s + i;
+
+	return NULL;
+}
+
+PUBLIC char *strrchr(char const *s, int c)
+{
+	size_t len = strlen(s);
+	size_t pos = len;
+
+	while (s[pos] != c && pos-- != 0)
+		;
+
+	if (pos == len)
+		return NULL;
+
+	return (char *)s + pos;
+}

Userspace/libc/src/std/sys/wait.c

@@ -0,0 +1,14 @@
+#include <sys/wait.h>
+
+PUBLIC pid_t wait(int *wstatus)
+{
+	return waitpid(-1, &wstatus, 0);
+}
+
+PUBLIC pid_t waitpid(pid_t pid, int *wstatus, int options)
+{
+}
+
+PUBLIC int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options)
+{
+}

Userspace/libc/src/std/sys_stat.c

@@ -0,0 +1,18 @@
+#include <sys/stat.h>
+
+#include <sys/types.h> // For PUBLIC
+
+PUBLIC int mkdir(const char *path, mode_t mode)
+{
+	return 0;
+}
+
+PUBLIC int remove(const char *pathname)
+{
+	return 0;
+}
+
+PUBLIC int rename(const char *oldpath, const char *newpath)
+{
+	return 0;
+}

Userspace/libc/src/std/uni/exe.c

@@ -0,0 +1,51 @@
+#include <unistd.h>
+#include <stddef.h>
+#include <errno.h>
+#include "../../../Kernel/syscalls.h"
+
+PUBLIC int execl(const char *pathname, const char *arg, ...)
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC int execlp(const char *file, const char *arg, ...)
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC int execle(const char *pathname, const char *arg, ...)
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC int execv(const char *pathname, char *const argv[])
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC int execvp(const char *file, char *const argv[])
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC int execvpe(const char *file, char *const argv[], char *const envp[])
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC int execve(const char *pathname, char *const argv[], char *const envp[])
+{
+    errno = ENOSYS;
+    return -1;
+}
+
+PUBLIC pid_t fork(void)
+{
+    return syscall0(sc_fork);
+}

Userspace/libc/src/std/uni/sleep.c

@@ -0,0 +1,14 @@
+#include <unistd.h>
+#include <stddef.h>
+#include <errno.h>
+#include "../../../Kernel/syscalls.h"
+
+PUBLIC unsigned int sleep(unsigned int seconds)
+{
+	// return syscall1(sys_Sleep, seconds * 1000000);
+}
+
+PUBLIC int usleep(useconds_t usec)
+{
+	// return syscall1(sys_Sleep, usec);
+}