[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)],
-            level_names[static_cast<uint8_t>(level)]);
+            area_names[entry->area], level_names[entry->severity]);
     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->area = area;
+    header->severity = static_cast<uint8_t>(severity);
+    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