Add temporary log output

Currently the kernel idle process is an infinite loop printing logs,
with no locking.

src/libraries/kutil/include/kutil/logger.h

@@ -55,6 +55,21 @@ public:
 		va_end(args);
 	}
 
+	struct entry
+	{
+		uint8_t bytes;
+		area_t area;
+		level severity;
+		uint8_t sequence;
+		char message[0];
+	};
+
+	/// Get the next log entry from the buffer
+	/// \arg buffer  The buffer to copy the log message into
+	/// \arg size    Size of the passed-in buffer, in bytes
+	/// \returns     Number of bytes copied into the buffer
+	size_t get_entry(void *buffer, size_t size);
+
 private:
 	friend void debug(area_t area, const char *fmt, ...);
 	friend void info (area_t area, const char *fmt, ...);

src/libraries/kutil/logger.cpp

@@ -9,17 +9,8 @@ namespace log {
 using kutil::memset;
 using kutil::memcpy;
 
-struct entry_header
-{
-	uint8_t bytes;
-	uint8_t area;
-	uint8_t level;
-	uint8_t sequence;
-	char message[0];
-};
-
 logger *logger::s_log = nullptr;
-const char *logger::s_level_names[] = {"debug", " info", " warn", "error", "fatal"};
+const char *logger::s_level_names[] = {"", "debug", " info", " warn", "error", "fatal"};
 
 logger::logger() :
 	m_buffer(nullptr, 0),
@@ -73,18 +64,18 @@ void
 logger::output(level severity, area_t area, const char *fmt, va_list args)
 {
 	uint8_t buffer[256];
-	entry_header *header = reinterpret_cast<entry_header *>(buffer);
-	header->bytes = sizeof(entry_header);
+	entry *header = reinterpret_cast<entry *>(buffer);
+	header->bytes = sizeof(entry);
 	header->area = area;
-	header->level = static_cast<uint8_t>(severity);
+	header->severity = severity;
 	header->sequence = m_sequence++;
 
 	header->bytes +=
-		vsnprintf(header->message, sizeof(buffer) - sizeof(entry_header), fmt, args);
+		vsnprintf(header->message, sizeof(buffer) - sizeof(entry), fmt, args);
 
 	uint8_t *out;
 	size_t n = m_buffer.reserve(header->bytes, reinterpret_cast<void**>(&out));
-	if (n < sizeof(entry_header)) {
+	if (n < sizeof(entry)) {
 		m_buffer.commit(0); // Cannot even write the header, abort
 		return;
 	}
@@ -96,6 +87,28 @@ logger::output(level severity, area_t area, const char *fmt, va_list args)
 	m_buffer.commit(n);
 }
 
+size_t
+logger::get_entry(void *buffer, size_t size)
+{
+	void *out;
+	size_t out_size = m_buffer.get_block(&out);
+	entry *ent = reinterpret_cast<entry *>(out);
+	if (out_size == 0)
+		return 0;
+
+	kassert(out_size >= sizeof(entry), "Couldn't read a full entry");
+	if (out_size < sizeof(entry))
+		return 0;
+
+	kassert(size >= ent->bytes, "Didn't pass a big enough buffer");
+	if (size < ent->bytes)
+		return 0;
+
+	memcpy(buffer, out, ent->bytes);
+	m_buffer.consume(ent->bytes);
+	return ent->bytes;
+}
+
 #define LOG_LEVEL_FUNCTION(name) \
 	void name (area_t area, const char *fmt, ...) { \
 		logger *l = logger::s_log; \