[kernel] Add a 'log available' signal to block on

There was previously no good way to block log-display tasks, either the
fb driver or the kernel log task. Now the system object has a signal
(j6_signal_system_has_log) that gets asserted when the log is written
to.

src/kernel/log.cpp

@@ -1,8 +1,10 @@
+#include "j6/signals.h"
 #include "kutil/memory.h"
 #include "kutil/no_construct.h"
 #include "console.h"
 #include "log.h"
-#include "scheduler.h"
+#include "objects/system.h"
+#include "objects/thread.h"
 
 static uint8_t log_buffer[0x10000];
 
@@ -26,29 +28,54 @@ output_log(log::area_t area, log::level severity, const char *message)
 	cons->set_color();
 }
 
+static void
+log_flush()
+{
+	system &sys = system::get();
+	sys.assert_signal(j6_signal_system_has_log);
+}
+
 void
 logger_task()
 {
-	uint8_t buffer[257];
-	auto *ent = reinterpret_cast<log::logger::entry *>(buffer);
 	auto *cons = console::get();
 
 	log::info(logs::task, "Starting kernel logger task");
 	g_logger.set_immediate(nullptr);
+	g_logger.set_flush(log_flush);
 
-	scheduler &s = scheduler::get();
+	thread &self = thread::current();
+	system &sys = system::get();
+
+	size_t buffer_size = 1;
+	uint8_t *buffer = nullptr;
 
 	while (true) {
-		if(g_logger.get_entry(buffer, sizeof(buffer))) {
+		size_t size = g_logger.get_entry(buffer, buffer_size);
+		if (size > buffer_size) {
+			while (size > buffer_size) buffer_size *= 2;
+			kutil::kfree(buffer);
+			buffer = reinterpret_cast<uint8_t*>(kutil::kalloc(buffer_size));
+			kassert(buffer, "Could not allocate logger task buffer");
+			continue;
+		}
+
+		if(size) {
+			auto *ent = reinterpret_cast<log::logger::entry *>(buffer);
 			buffer[ent->bytes] = 0;
+
 			cons->set_color(level_colors[static_cast<int>(ent->severity)]);
 			cons->printf("%7s %5s: %s\n",
 				g_logger.area_name(ent->area),
 				g_logger.level_name(ent->severity),
 				ent->message);
 			cons->set_color();
-		} else {
-			s.schedule();
+		}
+
+		if (!g_logger.has_log()) {
+			sys.deassert_signal(j6_signal_system_has_log);
+			sys.add_blocked_thread(&self);
+			self.wait_on_signals(&sys, j6_signal_system_has_log);
 		}
 	}
 }

src/kernel/main.cpp

@@ -200,7 +200,7 @@ kernel_main(args::header *header)
 	}
 
 	if (!has_video)
-		sched->create_kernel_task(logger_task, scheduler::max_priority-1, true);
+		sched->create_kernel_task(logger_task, scheduler::max_priority/2, true);
 	sched->create_kernel_task(stdout_task, scheduler::max_priority-1, true);
 
 	const char stdout_message[] = "Hello on the fake stdout channel\n";

src/kernel/objects/system.h

@@ -10,7 +10,7 @@ class system :
 public:
 	static constexpr kobject::type type = kobject::type::event;
 
-	inline static system * get() { return &s_instance; }
+	inline static system & get() { return s_instance; }
 
 private:
 	static system s_instance;

src/kernel/scheduler.cpp

@@ -112,7 +112,7 @@ load_process_image(uintptr_t phys, uintptr_t virt, size_t bytes, TCB *tcb)
 
 	j6_init_value *initv = push<j6_init_value>(tcb->rsp3);
 	initv->type = j6_init_handle_system;
-	initv->value = static_cast<uint64_t>(proc.add_handle(system::get()));
+	initv->value = static_cast<uint64_t>(proc.add_handle(&system::get()));
 
 	initv = push<j6_init_value>(tcb->rsp3);
 	initv->type = j6_init_handle_process;

src/kernel/syscalls/system.cpp

@@ -5,6 +5,7 @@
 #include "log.h"
 #include "objects/endpoint.h"
 #include "objects/thread.h"
+#include "objects/system.h"
 #include "syscalls/helpers.h"
 
 extern log::logger &g_logger;
@@ -33,8 +34,15 @@ system_noop()
 j6_status_t
 system_get_log(j6_handle_t sys, char *buffer, size_t *size)
 {
+	if (!size || (*size && !buffer))
+		return j6_err_invalid_arg;
+
+	size_t orig_size = *size;
 	*size = g_logger.get_entry(buffer, *size);
-	return j6_status_ok;
+	if (!g_logger.has_log())
+		system::get().deassert_signal(j6_signal_system_has_log);
+
+	return (*size > orig_size) ? j6_err_insufficient : j6_status_ok;
 }
 
 j6_status_t