kernel: switch to zpr for all printing and logging

Author: zhiayang

efx/source/efx_main.cpp

@@ -48,6 +48,9 @@ void efx::init()
 		auto kernelPath = options::get_option("kernel");
 		if(kernelPath.empty()) efi::abort("did not specify 'kernel' option!");
 
+
+		efi::println("reading kernel from disk...");
+
 		size_t len = 0;
 		auto buf = fs::readFile(kernelPath, &len);
 
@@ -90,8 +93,13 @@ void efx::init()
 			memset((uint8_t*) out + len, 0, pages * 0x1000 - len);
 
 			auto crc32 = [](const uint8_t* ptr, size_t buf_len) -> uint32_t {
-				static const uint32_t s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
-													0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
+				static const uint32_t s_crc32[16] = {
+					0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
+					0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
+					0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c,
+					0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
+				};
+
 				uint32_t crcu32 = 0;
 				if(!ptr) return 0;
 

efx/source/loader.cpp

@@ -192,7 +192,6 @@ namespace efx
 
 			switch(efiEnt->Type)
 			{
-
 				case EfiBootServicesCode:           // fallthrough
 				case EfiBootServicesData:           entries[k].memoryType = nx::MemoryType::Reserved; break;
 
@@ -242,6 +241,7 @@ namespace efx
 								entries[k].memoryType = (nx::MemoryType) customExtents[i].type;
 
 								bi->mmEntryCount += 1;
+								k += 1;
 							}
 						}
 					}
@@ -251,10 +251,14 @@ namespace efx
 
 				} break;
 
-				default:                            skip = true; break; // do not include
+				// do not include
+				default:
+					skip = true;
+					break;
 			}
 
-			if(skip) continue;
+			if(skip)
+				continue;
 
 			entries[k].address = efiEnt->PhysicalStart;
 			entries[k].numPages = efiEnt->NumberOfPages;
@@ -273,6 +277,7 @@ namespace efx
 
 				entries[k].address = customExtents[i].base;
 				entries[k].numPages = customExtents[i].num;
+				entries[k].memoryType = (nx::MemoryType) customExtents[i].type;
 				entries[k].efiAttributes = 0;
 
 				bi->mmEntryCount += 1;

efx/source/support/memory.cpp

@@ -113,9 +113,9 @@ namespace memory
 		{
 			auto entry = (efi_memory_descriptor*) (buffer + (i * descSz));
 
-			if(krt::match(entry->Type, EfiLoaderCode, EfiBootServicesCode, EfiBootServicesData, efi::MemoryType_BootInfo,
-				efi::MemoryType_MemoryMap, efi::MemoryType_Initrd, efi::MemoryType_KernelElf))
+			if(krt::match(entry->Type, EfiLoaderCode, EfiBootServicesCode, EfiBootServicesData))
 			{
+				// efi::println("map %p - %p", entry->PhysicalStart, entry->PhysicalStart + entry->NumberOfPages * 0x1000);
 				mapVirtual(entry->PhysicalStart, entry->PhysicalStart, entry->NumberOfPages);
 			}
 
@@ -295,7 +295,12 @@ namespace efi
 		efi::abort_if_error(stat, "failed to allocate memory for %s!", user);
 
 		// we need to pass the originally intended type to the accounting part.
-		efx::memory::accountMemory(out, numPages, memType);
+		if(efiType != memType)
+			efx::memory::accountMemory(out, numPages, memType);
+
+		// if this isn't for the vmm mapping, then map it in the kernel's (future) cr3
+		if(memType != efi::MemoryType_VMFrame)
+			efx::memory::mapVirtual(out, out, numPages);
 
 		return (void*) out;
 	}

kernel/include/defs.h

@@ -10,12 +10,75 @@
 
 #include "krt.h"
 
+#define ZPR_FREESTANDING 1
+#include <zst/zpr.h>
+
 using addr_t = uintptr_t;
 
 namespace nx
 {
 	constexpr size_t PAGE_SIZE = 0x1000;
 
+	[[noreturn]] void __internal_abort();
+	void console_print(const char* s, size_t len);
+
+	namespace interrupts
+	{
+		void enable();
+		void disable();
+	}
+
+	namespace serial
+	{
+		void debugprintchar(char c);
+		void debugprint(const char* c, size_t l);
+
+		template <typename... Args>
+		void debugprintf(const char* fmt, Args&&... args)
+		{
+			zpr::cprint(&serial::debugprint, fmt, static_cast<Args&&>(args)...);
+		}
+	}
+
+
+	template <typename... Args>
+	void print(const char* fmt, Args&&... args)
+	{
+		zpr::cprint(&console_print, fmt, static_cast<Args&&>(args)...);
+	}
+
+	template <typename... Args>
+	void println(const char* fmt, Args&&... args)
+	{
+		zpr::cprintln(&console_print, fmt, static_cast<Args&&>(args)...);
+	}
+
+	template <typename... Args>
+	[[noreturn]] void abort(const char* fmt, Args&&... args)
+	{
+		serial::debugprintf("\n\nkernel abort! error: ");
+		serial::debugprintf(fmt, static_cast<Args&&>(args)...);
+
+		__internal_abort();
+	}
+
+	template <typename... Args>
+	[[noreturn]] void assert_fail(const char* file, size_t line, const char* thing, const char* fmt, Args&&... args)
+	{
+		interrupts::disable();
+
+		println("failed assertion");
+		println("invariant: {}", thing);
+		print("reason:    ");
+		print(fmt, static_cast<Args&&>(args)...);
+
+		print("\nlocation:  {}:{}\n\n", file, line);
+
+		__internal_abort();
+	}
+
+
+
 	struct _allocator
 	{
 		static void* allocate(size_t sz, size_t align);
@@ -34,10 +97,18 @@ namespace nx
 
 	struct _aborter
 	{
-		static void abort(const char* fmt, ...);
-		static void debuglog(const char* fmt, ...);
-	};
+		template <typename... Args>
+		static void abort(const char* fmt, Args&&... args)
+		{
+			abort(fmt, static_cast<Args&&>(args)...);
+		}
 
+		template <typename... Args>
+		static void debuglog(const char* fmt, Args&&... args)
+		{
+			abort(fmt, static_cast<Args&&>(args)...);
+		}
+	};
 
 	// re-export the krt types with our own stuff.
 	using string = krt::string<_allocator, _aborter>;
@@ -76,19 +147,8 @@ namespace nx
 		constexpr auto none = krt::nullopt;
 	}
 
-
 	[[noreturn]] void halt();
 
-	[[noreturn]] void vabort(const char* fmt, va_list args);
-	[[noreturn]] void abort(const char* fmt, ...);
-
-	void vabort_nohalt(const char* fmt, va_list args);
-	void abort_nohalt(const char* fmt, ...);
-
-	[[noreturn]] void assert_fail(const char* file, size_t line, const char* thing);
-	[[noreturn]] void assert_fail(const char* file, size_t line, const char* thing, const char* fmt, ...);
-
-
 	namespace scheduler
 	{
 		struct Thread;
@@ -114,17 +174,28 @@ namespace nx
 		constexpr uint64_t ALIGN_BITS           = 12;
 	}
 
-	void dbg(const char* sys, const char* fmt, ...);
-	void log(const char* sys, const char* fmt, ...);
-	void warn(const char* sys, const char* fmt, ...);
-	void error(const char* sys, const char* fmt, ...);
+
+
+
+	template <typename... Args>
+	nx::string sprint(const char* fmt, Args&&... args)
+	{
+		nx::string ret;
+		zpr::cprint([&ret](const char* s, size_t len) {
+
+			ret += nx::string_view(s, len);
+
+		}, fmt, static_cast<Args&&>(args)...);
+
+		return ret;
+	}
 }
 
 // wow fucking c++ is so poorly designed
 namespace std
 {
 	enum class align_val_t : size_t { };
-	using max_align_t = long double;
+	// using max_align_t = long double;
 }
 
 [[nodiscard]] void* operator new    (size_t count);
@@ -145,11 +216,7 @@ void operator delete[]  (void* ptr, size_t al);
 #undef assert
 #endif
 
-#define assert(x)               ((x) ? ((void) 0) : ::nx::assert_fail(__FILE__, __LINE__, #x))
-
-#define VA_ARGS(...)            , ##__VA_ARGS__
-#define kassert(x, fmt, ...)    ((x) ? ((void) 0) : ::nx::assert_fail(__FILE__, __LINE__, #x, fmt VA_ARGS(__VA_ARGS__)))
-
+#define assert(x)               ((x) ? ((void) 0) : ::nx::assert_fail(__FILE__, __LINE__, #x, ""))
 
 #define __unlikely(x)           __builtin_expect((x), 0)
 #define __likely(x)             __builtin_expect((x), 1)

kernel/include/devices/serial.h

@@ -14,10 +14,8 @@ namespace nx
 		void init();
 		void initReceive(void (*callback)(uint8_t));
 
-		void debugprint(char c);
-		void debugprint(char* c, size_t l);
+		void debugprintchar(char c);
+		void debugprint(const char* c, size_t l);
 		void debugprint(const char* s);
-
-		void debugprintf(const char* fmt, ...);
 	}
 }

kernel/include/extmm.h

@@ -4,7 +4,7 @@
 
 #pragma once
 
-
+#include "log.h"
 #include "synchro.h"
 #include "devices/serial.h"
 
@@ -118,7 +118,7 @@ namespace extmm
 		template <typename Predicate>
 		addr_t allocate(size_t num, Predicate&& satisfies)
 		{
-			if(num == 0) abort("extmm/%s::allocate(): cannot allocate 0 pages!", this->owner);
+			if(num == 0) abort("extmm/{}::allocate(): cannot allocate 0 pages!", this->owner);
 
 			autolock lk(&this->lock);
 
@@ -155,7 +155,7 @@ namespace extmm
 				ext = ext->next;
 			}
 
-			error("extmm", "(%s): allocate() out of pages!", this->owner);
+			error("extmm", "({}): allocate() out of pages!", this->owner);
 			return 0;
 		}
 
@@ -198,7 +198,7 @@ namespace extmm
 				ext = ext->next;
 			}
 
-			serial::debugprintf("extmm/%s::allocateSpecific(): could not fulfil request!\n", this->owner);
+			serial::debugprintf("extmm/{}::allocateSpecific(): could not fulfil request!\n", this->owner);
 			return 0;
 		}
 
@@ -228,7 +228,7 @@ namespace extmm
 				else if(ext->addr == addr)
 				{
 					// hmm...
-					abort("extmm: potential double free! addr: %p, size: %zu", addr, num);
+					abort("extmm: potential double free! addr: {p}, size: {}", addr, num);
 				}
 
 				ext = ext->next;
@@ -241,11 +241,11 @@ namespace extmm
 
 		void dump()
 		{
-			serial::debugprintf("dumping extmm state %s (%p):\n", this->owner, this);
+			serial::debugprintf("dumping extmm state {} ({p}):\n", this->owner, this);
 			auto ext = this->head;
 			while(ext)
 			{
-				serial::debugprintf("    %p - %p (%zu)\n", ext->addr, end(ext), ext->size);
+				serial::debugprintf("    {p} - {p} ({})\n", ext->addr, end(ext), ext->size);
 				ext = ext->next;
 			}
 			serial::debugprintf("\n");
@@ -263,7 +263,7 @@ namespace extmm
 					// check if they intersect.
 					if(intersects(ext1, ext2))
 					{
-						error("extmm", "inconsistent extent state! (%p, %p, %zu) intersects (%p, %p, %zu)",
+						error("extmm", "inconsistent extent state! ({p}, {p}, {}) intersects ({p}, {p}, {})",
 							ext1->addr, end(ext1), ext1->size, ext2->addr, end(ext2), ext2->size);
 
 						return false;
@@ -274,7 +274,7 @@ namespace extmm
 
 				if(ext1->size == 0)
 				{
-					error("extmm", "inconsistent extent state! extent at %p has 0 size", ext1->addr);
+					error("extmm", "inconsistent extent state! extent at {p} has 0 size", ext1->addr);
 					return false;
 				}