[libj6] Create a standard definition of the log entry type

Move logger::entry to libj6 as j6_log_entry, and use that everywhere. It
was silly that it was copied into srv.logger and drv.uefi_fb

src/kernel/debugcon.cpp

@@ -26,22 +26,21 @@ namespace {
 } // anon namespace
 
 void
-output(logs area, log::level level, const char *message, size_t mlen)
+output(j6_log_entry *entry)
 {
     char buffer [256];
     size_t dlen = util::format({buffer, sizeof(buffer)}, "%7s %7s| ",
-            area_names[static_cast<uint8_t>(area)],
+            area_names[entry->area], level_names[entry->severity]);
-            level_names[static_cast<uint8_t>(level)]);
     debug_out(buffer, dlen);
 
-    debug_out(message, mlen);
+    debug_out(entry->message, entry->bytes - sizeof(j6_log_entry));
     debug_newline();
 }
 
 void
 logger_task()
 {
-    using entry = log::logger::entry;
+    using entry = j6_log_entry;
 
     uint64_t seen = 0;
     size_t buf_size = 128;
@@ -58,7 +57,7 @@ logger_task()
             continue;
         }
 
-        output(header->area, header->severity, header->message, size - sizeof(entry));
+        output(header);
         seen = header->id;
     }
 }

src/kernel/logger.cpp

@@ -56,26 +56,26 @@ void
 logger::output(level severity, logs area, const char *fmt, va_list args)
 {
     static constexpr size_t buffer_len = 256;
-    static constexpr size_t message_len = buffer_len - sizeof(entry);
+    static constexpr size_t message_len = buffer_len - sizeof(j6_log_entry);
 
     char buffer[buffer_len];
-    entry *header = reinterpret_cast<entry *>(buffer);
+    j6_log_entry *header = reinterpret_cast<j6_log_entry *>(buffer);
 
-    size_t size = sizeof(entry);
+    size_t size = sizeof(j6_log_entry);
     size += util::vformat({header->message, message_len}, fmt, args);
 
     util::scoped_lock lock {m_lock};
 
     while (free() < size) {
         // Remove old entries until there's enough space
-        const entry *first = util::at<const entry>(m_buffer, start());
+        const j6_log_entry *first = util::at<const j6_log_entry>(m_buffer, start());
         m_start += first->bytes;
     }
 
     header->id = ++m_count;
     header->bytes = size;
-    header->severity = severity;
+    header->severity = static_cast<uint8_t>(severity);
-    header->area = area;
+    header->area = static_cast<uint8_t>(area);
 
     memcpy(util::at<void>(m_buffer, end()), buffer, size);
     m_end += size;
@@ -95,11 +95,11 @@ logger::get_entry(uint64_t seen, void *buffer, size_t size)
     }
 
     size_t off = m_start;
-    entry *ent = util::at<entry>(m_buffer, off);
+    j6_log_entry *ent = util::at<j6_log_entry>(m_buffer, off);
     while (seen >= ent->id) {
         off += ent->bytes;
         kassert(off < m_end, "Got to the end while looking for new log entry");
-        ent = util::at<entry>(m_buffer, off);
+        ent = util::at<j6_log_entry>(m_buffer, off);
     }
 
     if (size >= ent->bytes)

src/kernel/logger.h

@@ -57,15 +57,6 @@ public:
         va_end(args);
     }
 
-    struct entry
-    {
-        uint64_t id    : 42;
-        uint16_t bytes : 11;
-        level severity :  4;
-        logs area      :  7;
-        char message[0];
-    };
-
     /// Get the next log entry from the buffer. Blocks the current thread until
     /// a log arrives if there are no entries newer than `seen`.
     /// \arg seen    The id of the last-seen log entry, or 0 for none

src/libraries/j6/j6/types.h

@@ -50,3 +50,12 @@ struct j6_handle_descriptor
     j6_object_type type;
 };
 
+/// Log entries as returned by j6_system_get_log
+struct j6_log_entry
+{
+    uint64_t id       : 42;
+    uint64_t bytes    : 11;
+    uint64_t severity :  4;
+    uint64_t area     :  7;
+    char message[0];
+};

src/user/srv.logger/main.cpp

@@ -20,15 +20,6 @@ extern "C" {
 extern j6_handle_t __handle_self;
 j6_handle_t g_handle_sys = j6_handle_invalid;
 
-struct entry
-{
-    uint64_t id      : 42;
-    uint16_t bytes   : 11;
-    uint8_t severity :  4;
-    uint8_t area     :  7;
-    char message[0];
-};
-
 static const uint8_t level_colors[] = {0x00, 0x09, 0x01, 0x0b, 0x0f, 0x07, 0x08};
 char const * const level_names[] = {"", "fatal", "error", "warn", "info", "verbose", "spam"};
 char const * const area_names[] = {
@@ -96,17 +87,19 @@ log_pump_proc(j6_handle_t cout)
             continue;
         }
 
-        const entry *e = reinterpret_cast<entry*>(message_buffer);
+        const j6_log_entry *e = reinterpret_cast<j6_log_entry*>(message_buffer);
 
         seen = e->id;
         const char *area_name = area_names[e->area];
         const char *level_name = level_names[e->severity];
         uint8_t level_color = level_colors[e->severity];
 
+        int message_len = static_cast<int>(e->bytes - sizeof(j6_log_entry));
         size_t len = snprintf(stringbuf, sizeof(stringbuf),
-                "\e[38;5;%dm%7s %7s: %s\e[38;5;0m\r\n",
+                "\e[38;5;%dm%7s %7s: %.*s\e[38;5;0m\r\n",
-                level_color, area_name, level_name, e->message);
+                level_color, area_name, level_name,
-        send_all(cout, stringbuf, len);
+                message_len, e->message);
+        send_all(cout, stringbuf, len + 1);
     }
 }