[libj6] Add log area and severity to j6::syslog()

User code can now set the log area and severity of log messages. This also updates the j6_log
syscall to take these parameters, but removes all calls to it except through j6::syslog().

definitions/syscalls.def

@@ -24,6 +24,8 @@ interface syscalls [syscall] {
 
     # Write a message to the kernel log
     function log {
+        param area uint8
+        param severity uint8
         param message string
     }
 

src/kernel/logger.cpp

@@ -124,7 +124,8 @@ LOG_LEVEL_FUNCTION(info);
 LOG_LEVEL_FUNCTION(warn);
 LOG_LEVEL_FUNCTION(error);
 
-void fatal(logs area, const char *fmt, ...)
+void
+fatal(logs area, const char *fmt, ...)
 {
     logger *l = logger::s_log;
     if (!l) return;
@@ -137,4 +138,19 @@ void fatal(logs area, const char *fmt, ...)
     kassert(false, "log::fatal");
 }
 
+void
+log(logs area, level severity, const char *fmt, ...)
+{
+    logger *l = logger::s_log;
+    if (!l) return;
+
+    level limit = l->get_level(area);
+    if (severity > limit) return;
+
+    va_list args;
+    va_start(args, fmt);
+    l->output(severity, area, fmt, args);
+    va_end(args);
+}
+
 } // namespace log

src/kernel/logger.h

@@ -77,6 +77,7 @@ private:
     friend void warn   (logs area, const char *fmt, ...);
     friend void error  (logs area, const char *fmt, ...);
     friend void fatal  (logs area, const char *fmt, ...);
+    friend void log    (logs area, level severity, const char *fmt, ...);
 
     void output(level severity, logs area, const char *fmt, va_list args);
 
@@ -113,6 +114,8 @@ void warn   (logs area, const char *fmt, ...);
 void error  (logs area, const char *fmt, ...);
 void fatal  (logs area, const char *fmt, ...);
 
+void log    (logs area, level severity, const char *fmt, ...);
+
 } // namespace log
 
 extern log::logger &g_logger;

src/kernel/syscalls/system.cpp

@@ -21,10 +21,11 @@ namespace syscalls {
 using system = class ::system;
 
 j6_status_t
-log(const char *message)
+log(uint8_t area, uint8_t severity, const char *message)
 {
     thread &th = thread::current();
-    log::info(logs::syscall, "Message <%02lx:%02lx>: %s", th.parent().obj_id(), th.obj_id(), message);
+    log::log(static_cast<logs>(area), static_cast<log::level>(severity),
+        "<%02lx:%02lx>: %s", th.parent().obj_id(), th.obj_id(), message);
     return j6_status_ok;
 }
 

src/libraries/j6/channel.cpp

@@ -47,7 +47,7 @@ channel::create(size_t size)
     j6_handle_t vma = j6_handle_invalid;
 
     if (size < arch::frame_size || (size & (size - 1)) != 0) {
-        syslog("Bad channel size: %lx", size);
+        syslog(j6::logs::ipc, j6::log_level::error, "Bad channel size: %lx", size);
         return nullptr;
     }
 
@@ -58,7 +58,7 @@ channel::create(size_t size)
 
     result = j6_vma_create_map(&vma, size, &addr, j6_vm_flag_write|j6_vm_flag_ring);
     if (result != j6_status_ok) {
-        syslog("Failed to create channel VMA. Error: %lx", result);
+        syslog(j6::logs::ipc, j6::log_level::error, "Failed to create channel VMA. Error: %lx", result);
         return nullptr;
     }
 
@@ -79,7 +79,7 @@ channel::open(j6_handle_t vma)
 
     result = j6_vma_map(vma, 0, &addr, 0);
     if (result != j6_status_ok) {
-        syslog("Failed to map channel VMA. Error: %lx", result);
+        syslog(j6::logs::ipc, j6::log_level::error, "Failed to map channel VMA. Error: %lx", result);
         return nullptr;
     }
 

src/libraries/j6/condition.cpp

@@ -12,7 +12,7 @@ namespace j6 {
 void
 condition::wait()
 {
-    j6::syslog("Waiting on condition %lx", this);
+    j6::syslog(j6::logs::app, j6::log_level::verbose, "Waiting on condition %lx", this);
     uint32_t v = __atomic_add_fetch(&m_state, 1, __ATOMIC_ACQ_REL);
     j6_status_t s = j6_futex_wait(&m_state, v, 0);
     while (s == j6_status_futex_changed) {
@@ -20,7 +20,7 @@ condition::wait()
         if (v == 0) break;
         s = j6_futex_wait(&m_state, v, 0);
     }
-    j6::syslog("Woke on condition %lx", this);
+    j6::syslog(j6::logs::app, j6::log_level::verbose, "Woke on condition %lx", this);
 }
 
 void

src/libraries/j6/include/j6/syslog.hh

@@ -2,15 +2,26 @@
 /// \file j6/syslog.hh
 /// Utility function for writing messages to the kernel log
 
-#include <util/api.h>
-
 // The kernel depends on libj6 for some shared code,
 // but should not include the user-specific code.
 #ifndef __j6kernel
+#include <stdint.h>
+#include <util/api.h>
 
 namespace j6 {
 
-void API syslog(const char *fmt, ...);
+enum class logs : uint8_t {
+#define LOG(name, lvl) name,
+#include <j6/tables/log_areas.inc>
+#undef LOG
+    COUNT
+};
+
+enum class log_level : uint8_t {
+    silent, fatal, error, warn, info, verbose, spam, max
+};
+
+void API syslog(logs area, log_level severity, const char *fmt, ...);
 
 } // namespace j6
 

src/libraries/j6/include/j6/tables/log_areas.inc

@@ -10,3 +10,6 @@ LOG(syscall,verbose)
 LOG(task,   verbose)
 LOG(timer,  info)
 LOG(ipc,    spam)
+LOG(app,    spam)
+LOG(proto,    spam)
+LOG(srv,    spam)

src/libraries/j6/protocols/service_locator.cpp

@@ -42,7 +42,7 @@ client::lookup_service(uint64_t proto_id, j6_handle_t &handle)
     size_t data_size = sizeof(proto_id);
     handle = j6_handle_invalid;
 
-    j6::syslog("Looking up service for %x", proto_id);
+    j6::syslog(j6::logs::proto, j6::log_level::verbose, "Looking up service for %x", proto_id);
     j6_status_t s = j6_mailbox_call(m_service, &tag,
         &data, &data_size, data_size,
         &handle, &handle_count);

src/libraries/j6/syslog.cpp

@@ -9,7 +9,7 @@
 namespace j6 {
 
 void
-syslog(const char *fmt, ...)
+syslog(logs area, log_level severity, const char *fmt, ...)
 {
     char buffer[200];
 
@@ -19,7 +19,7 @@ syslog(const char *fmt, ...)
     va_end(va);
 
     buffer[n] = 0;
-    j6_log(buffer);
+    j6_log(static_cast<uint8_t>(area), static_cast<uint8_t>(severity), buffer);
 }
 
 } // namespace j6

src/user/drv.uart/main.cpp

@@ -36,7 +36,7 @@ constexpr uintptr_t stack_top = 0xf80000000;
 int
 main(int argc, const char **argv)
 {
-    j6_log("uart driver starting");
+    j6::syslog(j6::logs::srv, j6::log_level::info, "uart driver starting");
 
     j6_handle_t event = j6_handle_invalid;
     j6_status_t result = j6_status_ok;
@@ -93,11 +93,11 @@ main(int argc, const char **argv)
             if (result != j6_status_ok)
                 break;
 
-            //j6::syslog("uart driver: got %d bytes from channel", size);
+            j6::syslog(j6::logs::srv, j6::log_level::spam, "uart driver: got %d bytes from channel", size);
             com1.write(buffer, size);
         }
         if (result != j6_status_would_block)
-            j6::syslog("uart driver: error %lx receiving from channel", result);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "uart driver: error %lx receiving from channel", result);
 
         uint64_t signals = 0;
         result = j6_event_wait(event, &signals, 500);
@@ -107,10 +107,10 @@ main(int argc, const char **argv)
         }
 
         if (result != j6_status_ok) {
-            j6::syslog("uart driver: error %lx waiting for irq", result);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "uart driver: error %lx waiting for irq", result);
             continue;
         } else {
-            j6::syslog("uart driver: irq signals: %lx", signals);
+            j6::syslog(j6::logs::srv, j6::log_level::verbose, "uart driver: irq signals: %lx", signals);
         }
 
         if (signals & (1<<0))
@@ -119,7 +119,7 @@ main(int argc, const char **argv)
             com1.handle_interrupt();
     }
 
-    j6_log("uart driver somehow got to the end of main");
+    j6::syslog(j6::logs::srv, j6::log_level::error, "uart driver somehow got to the end of main");
     return 0;
 }
 

src/user/drv.uefi_fb/main.cpp

@@ -22,7 +22,7 @@ extern "C" {
 int
 main(int argc, const char **argv, const char **env)
 {
-    j6::syslog("fb driver starting");
+    j6::syslog(j6::logs::srv, j6::log_level::info, "fb driver starting");
 
     using bootproto::devices::uefi_fb;
     using bootproto::devices::video_mode;
@@ -32,7 +32,7 @@ main(int argc, const char **argv, const char **env)
     const uefi_fb *fb = reinterpret_cast<const uefi_fb*>(init->argv[0]);
 
     if (!fb || !fb->framebuffer) {
-        j6::syslog("fb driver didn't find a framebuffer, exiting");
+        j6::syslog(j6::logs::srv, j6::log_level::error, "fb driver didn't find a framebuffer, exiting");
         return 1;
     }
 
@@ -104,7 +104,7 @@ main(int argc, const char **argv, const char **env)
             buffer_size = size;
             continue;
         } else if (s != j6_status_ok) {
-            j6::syslog("fb driver got error from get_log, quitting");
+            j6::syslog(j6::logs::srv, j6::log_level::error, "fb driver got error from get_log, quitting");
             return s;
         }
 
@@ -130,6 +130,6 @@ main(int argc, const char **argv, const char **env)
         }
     }
 
-    j6::syslog("fb driver done, exiting");
+    j6::syslog(j6::logs::srv, j6::log_level::info, "fb driver done, exiting");
     return 0;
 }

src/user/ld.so/image.cpp

@@ -64,20 +64,20 @@ load_image(image_list::item_type &img, j6::proto::vfs::client &vfs)
     j6_handle_t vma = j6_handle_invalid;
     j6_status_t r = vfs.load_file(path, vma, file_size);
     if (r != j6_status_ok) {
-        j6::syslog("Error %d opening %s", r, path);
+        j6::syslog(j6::logs::app, j6::log_level::error, "Error %d opening %s", r, path);
         return 0;
     }
 
     uintptr_t file_addr = 0;
     r = j6_vma_map(vma, 0, &file_addr, 0);
     if (r != j6_status_ok) {
-        j6::syslog("Error %d opening %s", r, path);
+        j6::syslog(j6::logs::app, j6::log_level::error, "Error %d opening %s", r, path);
         return 0;
     }
 
     elf::file file { util::const_buffer::from(file_addr, file_size) };
     if (!file.valid(elf::filetype::shared)) {
-        j6::syslog("Error opening %s: Not an ELF shared object", path);
+        j6::syslog(j6::logs::app, j6::log_level::error, "Error opening %s: Not an ELF shared object", path);
         return 0;
     }
 
@@ -105,7 +105,7 @@ load_image(image_list::item_type &img, j6::proto::vfs::client &vfs)
         j6_handle_t sub_vma = j6_handle_invalid;
         j6_status_t res = j6_vma_create_map(&sub_vma, seg.mem_size+prologue, &addr, flags);
         if (res != j6_status_ok) {
-            j6::syslog("  ** error loading ELF '%s': creating sub vma: %lx", path, res);
+            j6::syslog(j6::logs::app, j6::log_level::error, "error loading '%s': creating sub vma: %lx", path, res);
             return 0;
         }
 
@@ -279,11 +279,11 @@ image_list::load(j6_handle_t vfs_mb, uintptr_t addr)
         // Load the file
         addr = load_image(*img, vfs);
         if (!img->got) {
-            j6::syslog("Error opening %s: Could not find GOT", img->name);
+            j6::syslog(j6::logs::app, j6::log_level::error, "Error opening %s: Could not find GOT", img->name);
             return;
         }
 
-        j6::syslog("Loaded %s at base address 0x%x", img->name, img->base);
+        j6::syslog(j6::logs::app, j6::log_level::verbose, "Loaded %s at base address 0x%x", img->name, img->base);
         addr = (addr & ~0xffffull) + 0x10000;
 
         // Find the DT_NEEDED entries
@@ -317,7 +317,7 @@ image::parse_rela_table(const util::counted<const rela> &table, image_list &ctx)
             break;
 
         default:
-            j6::syslog("Unknown rela relocation type %d in %s", rel.type, name);
+            j6::syslog(j6::logs::app, j6::log_level::verbose, "Unknown rela relocation type %d in %s", rel.type, name);
             exit(126);
             break;
         }

src/user/srv.init/acpi.cpp

@@ -13,7 +13,7 @@ inline constexpr j6_vm_flags mmio_flags = (j6_vm_flags)(j6_vm_flag_write | j6_vm
 void
 probe_pci(j6_handle_t sys, pci_group &pci)
 {
-    j6::syslog("Probing PCI group at base %016lx", pci.base);
+    j6::syslog(j6::logs::srv, j6::log_level::info, "Probing PCI group at base %016lx", pci.base);
     map_phys(sys, pci.base, bus_mmio_size, mmio_flags);
 
     for (unsigned b = pci.bus_start; b <= pci.bus_end; ++b) {
@@ -57,7 +57,7 @@ load_mcfg(j6_handle_t sys, const acpi::table_header *header)
 
         probe_pci(sys, group);
 
-        j6::syslog("  Found MCFG entry: base %lx  group %d  bus %d-%d",
+        j6::syslog(j6::logs::srv, j6::log_level::info, "  Found MCFG entry: base %lx  group %d  bus %d-%d",
                 mcfge.base, mcfge.group, mcfge.bus_start, mcfge.bus_end);
     }
 
@@ -74,7 +74,7 @@ load_acpi(j6_handle_t sys, const bootproto::module *mod)
 
     const void *root_table = info->root;
     if (!root_table) {
-        j6::syslog("null ACPI root table pointer");
+        j6::syslog(j6::logs::srv, j6::log_level::error, "null ACPI root table pointer");
         return;
     }
 
@@ -88,7 +88,7 @@ load_acpi(j6_handle_t sys, const bootproto::module *mod)
     for (size_t i = 0; i < num_tables; ++i) {
         const acpi::table_header *header = xsdt->headers[i];
         if (!header->validate()) {
-            j6::syslog("ACPI table at %lx failed validation", header);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "ACPI table at %lx failed validation", header);
             continue;
         }
 

src/user/srv.init/initfs.cpp

@@ -59,7 +59,7 @@ initfs_start(j6romfs::fs &fs, j6_handle_t mb)
 
     while (initfs_running) {
         if (s != j6_status_ok) {
-            j6::syslog("initfs: error in j6_mailbox_respond: %x", s);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "initfs: error in j6_mailbox_respond: %x", s);
             return;
         }
 

src/user/srv.init/loader.cpp

@@ -105,7 +105,7 @@ load_program_into(j6_handle_t proc, elf::file &file, uintptr_t image_base, const
         j6_handle_t sub_vma = j6_handle_invalid;
         j6_status_t res = j6_vma_create_map(&sub_vma, seg.mem_size+prologue, &addr, flags);
         if (res != j6_status_ok) {
-            j6::syslog("  ** error loading ELF '%s': creating sub vma: %lx", path, res);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': creating sub vma: %lx", path, res);
             return 0;
         }
 
@@ -121,16 +121,16 @@ load_program_into(j6_handle_t proc, elf::file &file, uintptr_t image_base, const
             eop = eos;
 
         uintptr_t start_addr = (image_base + seg.vaddr) & ~0xfffull;
-        j6::syslog("Mapping segment from %s at %012lx - %012lx", path, start_addr, start_addr+seg.mem_size);
+        j6::syslog(j6::logs::srv, j6::log_level::verbose, "Mapping segment from %s at %012lx - %012lx", path, start_addr, start_addr+seg.mem_size);
         res = j6_vma_map(sub_vma, proc, &start_addr, j6_vm_flag_exact);
         if (res != j6_status_ok) {
-            j6::syslog("  ** error loading ELF '%s': mapping sub vma to child: %lx", path, res);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': mapping sub vma to child: %lx", path, res);
             return 0;
         }
 
         res = j6_vma_unmap(sub_vma, 0);
         if (res != j6_status_ok) {
-            j6::syslog("  ** error loading ELF '%s': unmapping sub vma: %lx", path, res);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': unmapping sub vma: %lx", path, res);
             return 0;
         }
     }
@@ -144,7 +144,7 @@ give_handle(j6_handle_t proc, j6_handle_t h, const char *name)
     if (h != j6_handle_invalid) {
         j6_status_t res = j6_process_give_handle(proc, h);
         if (res != j6_status_ok) {
-            j6::syslog("  ** error loading program: giving %s handle: %lx", name, res);
+            j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': giving handle: %lx", name, res);
             return false;
         }
     }
@@ -158,7 +158,7 @@ create_process(j6_handle_t sys, j6_handle_t slp, j6_handle_t vfs)
     j6_handle_t proc = j6_handle_invalid;
     j6_status_t res = j6_process_create(&proc);
     if (res != j6_status_ok) {
-        j6::syslog("  ** error loading program: creating process: %lx", res);
+        j6::syslog(j6::logs::srv, j6::log_level::error, "error loading program: creating process: %lx", res);
         return j6_handle_invalid;
     }
 
@@ -175,7 +175,7 @@ load_file(const j6romfs::fs &fs, const char *path)
     if (!in || in->type != j6romfs::inode_type::file)
         return {};
 
-    j6::syslog("  Loading file: %s", path);
+    j6::syslog(j6::logs::srv, j6::log_level::info, "  Loading file: %s", path);
 
     uint8_t *data = new uint8_t [in->size];
     util::buffer program {data, in->size};
@@ -191,7 +191,7 @@ load_program(
         j6_handle_t sys, j6_handle_t slp, j6_handle_t vfs,
         const module *arg)
 {
-    j6::syslog("Loading program '%s' into new process", path);
+    j6::syslog(j6::logs::srv, j6::log_level::info, "Loading program '%s' into new process", path);
     util::buffer program_data = load_file(fs, path);
     if (!program_data.pointer)
         return false;
@@ -204,7 +204,7 @@ load_program(
         program_image_base = (rng.next() & 0xffe0 + 16) << 20;
 
     if (!program_elf.valid(dyn ? elf::filetype::shared : elf::filetype::executable)) {
-        j6::syslog("  ** error loading program '%s': ELF is invalid", path);
+        j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': ELF is invalid", path);
         return false;
     }
 
@@ -217,7 +217,7 @@ load_program(
     j6_handle_t stack_vma = j6_handle_invalid;
     j6_status_t res = j6_vma_create_map(&stack_vma, stack_size, &stack_addr, j6_vm_flag_write);
     if (res != j6_status_ok) {
-        j6::syslog("  ** error loading program '%s': creating stack vma: %lx", path, res);
+        j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': creating stack vma: %lx", path, res);
         return false;
     }
 
@@ -278,7 +278,7 @@ load_program(
 
                 elf::file ldso_elf {ldso_data};
                 if (!ldso_elf.valid(elf::filetype::shared)) {
-                    j6::syslog("  ** error loading dynamic linker for program '%s': ELF is invalid", path);
+                    j6::syslog(j6::logs::srv, j6::log_level::error, "error loading dynamic linker for '%s': ELF is invalid", path);
                     return false;
                 }
 
@@ -296,20 +296,20 @@ load_program(
     uintptr_t stack_base = stack_top-stack_size;
     res = j6_vma_map(stack_vma, proc, &stack_base, j6_vm_flag_exact);
     if (res != j6_status_ok) {
-        j6::syslog("  ** error loading program '%s': mapping stack vma: %lx", path, res);
+        j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': mapping stack vma: %lx", path, res);
         return false;
     }
 
     res = j6_vma_unmap(stack_vma, 0);
     if (res != j6_status_ok) {
-        j6::syslog("  ** error loading program '%s': unmapping stack vma: %lx", path, res);
+        j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': unmapping stack vma: %lx", path, res);
         return false;
     }
 
     j6_handle_t thread = j6_handle_invalid;
     res = j6_thread_create(&thread, proc, stack.child_pointer(), entrypoint, program_image_base, 0);
     if (res != j6_status_ok) {
-        j6::syslog("  ** error loading program '%s': creating thread: %lx", path, res);
+        j6::syslog(j6::logs::srv, j6::log_level::error, "error loading '%s': creating thread: %lx", path, res);
         return false;
     }
 

src/user/srv.init/main.cpp

@@ -40,7 +40,7 @@ main(int argc, const char **argv, const char **env)
     j6_handle_t vfs_mb = j6_handle_invalid;
     j6_handle_t vfs_mb_child = j6_handle_invalid;
 
-    j6_log("srv.init starting");
+    j6::syslog(j6::logs::srv, j6::log_level::info, "srv.init starting");
 
     sys = j6_find_first_handle(j6_object_type_system);
     if (sys == j6_handle_invalid)
@@ -115,7 +115,7 @@ main(int argc, const char **argv, const char **env)
     j6_handle_t initrd_vma =
         map_phys(sys, initrd_buf.pointer, initrd_buf.count);
     if (initrd_vma == j6_handle_invalid) {
-        j6_log("  ** error loading ramdisk: mapping physical vma");
+        j6::syslog(j6::logs::srv, j6::log_level::info, "error loading ramdisk: mapping physical vma");
         return 4;
     }
 
@@ -137,7 +137,7 @@ main(int argc, const char **argv, const char **env)
                 break;
 
             default:
-                j6::syslog("Unknown device type id: %lx", m->type_id);
+                j6::syslog(j6::logs::srv, j6::log_level::warn, "Unknown device type id: %lx", m->type_id);
         }
     }
 

src/user/srv.init/modules.cpp

@@ -5,6 +5,7 @@
 #include <arch/memory.h>
 #include <j6/errors.h>
 #include <j6/syscalls.h>
+#include <j6/syslog.hh>
 
 #include "loader.h"
 #include "modules.h"
@@ -23,7 +24,7 @@ load_modules(
     while (p) {
         j6_handle_t mod_vma = map_phys(system, p, arch::frame_size);
         if (mod_vma == j6_handle_invalid) {
-            j6_log("  ** error loading modules: mapping physical vma");
+            j6::syslog(j6::logs::srv, j6::log_level::error, "error loading modules: mapping physical vma");
             return;
         }
 

src/user/srv.init/pci.cpp

@@ -99,11 +99,11 @@ pci_device::pci_device(pci_group &group, uint8_t bus, uint8_t device, uint8_t fu
 
     uint16_t *status = command + 1;
 
-    j6::syslog("Found PCIe device at %02d:%02d:%d of type %x.%x.%x id %04x:%04x",
+    j6::syslog(j6::logs::srv, j6::log_level::info, "Found PCIe device at %02d:%02d:%d of type %x.%x.%x id %04x:%04x",
             bus, device, func, m_class, m_subclass, m_progif, m_vendor, m_device);
 
-    j6::syslog("  = BAR0 %016lld", get_bar(0));
+    j6::syslog(j6::logs::srv, j6::log_level::verbose, "  = BAR0 %016lld", get_bar(0));
-    j6::syslog("  = BAR1 %016lld", get_bar(1));
+    j6::syslog(j6::logs::srv, j6::log_level::verbose, "  = BAR1 %016lld", get_bar(1));
 
     if (*status & 0x0010) {
         // Walk the extended capabilities list

src/user/srv.init/service_locator.cpp

@@ -33,7 +33,7 @@ service_locator_start(j6_handle_t mb)
     j6_handle_t give_handle = j6_handle_invalid;
     uint64_t proto_id;
 
-    j6::syslog("SL> Starting service locator on mbx handle %x", mb);
+    j6::syslog(j6::logs::proto, j6::log_level::verbose, "SL> Starting service locator on mbx handle %x", mb);
 
     while (true) {
         uint64_t data_len = sizeof(uint64_t);
@@ -56,7 +56,7 @@ service_locator_start(j6_handle_t mb)
                 break;
             }
 
-            j6::syslog("SL> Registering handle %x for proto %x", give_handle, proto_id);
+            j6::syslog(j6::logs::proto, j6::log_level::verbose, "SL> Registering handle %x for proto %x", give_handle, proto_id);
 
             services.insert( {proto_id, give_handle} );
             tag = j6_proto_base_status;
@@ -72,10 +72,10 @@ service_locator_start(j6_handle_t mb)
             {
                 auto found = services.find(proto_id);
                 if (found != services.end()) {
-                    j6::syslog("SL> Found handle %x for proto %x", give_handle, proto_id);
+                    j6::syslog(j6::logs::proto, j6::log_level::verbose, "SL> Found handle %x for proto %x", give_handle, proto_id);
                     give_handle = found->second;
                 } else {
-                    j6::syslog("SL> Found no handles for proto %x", proto_id);
+                    j6::syslog(j6::logs::proto, j6::log_level::verbose, "SL> Found no handles for proto %x", proto_id);
                     give_handle = j6_handle_invalid;
                 }
             }

src/user/srv.logger/main.cpp

@@ -1,4 +1,3 @@
-#include <new>
 #include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -11,6 +10,7 @@
 #include <j6/protocols/service_locator.hh>
 #include <j6/syscalls.h>
 #include <j6/sysconf.h>
+#include <j6/syslog.hh>
 #include <j6/types.h>
 #include <util/hash.h>
 
@@ -70,7 +70,7 @@ log_pump_proc(j6::channel *cout)
             message_buffer = malloc(buffer_size);
             continue;
         } else if (s != j6_status_ok) {
-            j6_log("uart driver got error from get_log");
+            j6::syslog(j6::logs::srv, j6::log_level::warn, "log server got error from get_log");
             continue;
         }
 
@@ -93,7 +93,7 @@ log_pump_proc(j6::channel *cout)
 int
 main(int argc, const char **argv)
 {
-    j6_log("logging server starting");
+    j6::syslog(j6::logs::srv, j6::log_level::info, "logging server starting");
 
     g_handle_sys = j6_find_init_handle(0);
     if (g_handle_sys == j6_handle_invalid)

src/user/testapp/main.cpp

@@ -38,7 +38,7 @@ test_floats()
 
     for (int i = 0; i < len; ++i) {
         if (bs[i] != orig * i * mult) {
-            j6::syslog("ERROR: floating point discrepency");
+            j6::syslog(j6::logs::app, j6::log_level::error, "ERROR: floating point discrepency");
             return false;
         }
     }
@@ -49,7 +49,7 @@ test_floats()
 void
 thread_proc(void* channelp)
 {
-    j6_log("sub thread starting");
+    j6::syslog(j6::logs::app, j6::log_level::info, "sub thread starting");
 
     for (int i = 0; i < 100; ++i)
         if (!test_floats()) break;
@@ -66,7 +66,7 @@ thread_proc(void* channelp)
     if (result != j6_status_ok)
         j6_thread_exit();
 
-    j6_log("sub thread received message");
+    j6::syslog(j6::logs::app, j6::log_level::info, "sub thread received message");
 
     for (int i = 0; i < len; ++i)
         if (buffer[i] >= 'A' && buffer[i] <= 'Z')
@@ -76,12 +76,12 @@ thread_proc(void* channelp)
     if (result != j6_status_ok)
         j6_thread_exit();
 
-    j6_log("sub thread sent message");
+    j6::syslog(j6::logs::app, j6::log_level::info, "sub thread sent message");
 
     for (int i = 1; i < 5; ++i)
         j6_thread_sleep(i*10);
 
-    j6_log("sub thread exiting");
+    j6::syslog(j6::logs::app, j6::log_level::info, "sub thread exiting");
     j6_thread_exit();
 }
 
@@ -90,10 +90,10 @@ main(int argc, const char **argv)
 {
     j6_signal_t out = 0;
 
-    j6_log("main thread starting");
+    j6::syslog(j6::logs::app, j6::log_level::info, "main thread starting");
 
     for (int i = 0; i < argc; ++i)
-        j6_log(argv[i]);
+        j6::syslog(j6::logs::app, j6::log_level::info, argv[i]);
 
     void *base = malloc(0x1000);
     if (!base)
@@ -103,20 +103,20 @@ main(int argc, const char **argv)
     for (int i = 0; i < 3; ++i)
         vma_ptr[i*100] = uint64_t(i);
 
-    j6_log("main thread wrote to memory area");
+    j6::syslog(j6::logs::app, j6::log_level::info, "main thread wrote to memory area");
 
     j6::channel *chan = j6::channel::create(0x2000);
     if (!chan)
         return 1002;
 
-    j6_log("main thread created channel");
+    j6::syslog(j6::logs::app, j6::log_level::info, "main thread created channel");
 
     j6::thread child_thread {[=](){ thread_proc(chan); }, stack_top};
     j6_status_t result = child_thread.start();
     if (result != j6_status_ok)
         return result;
 
-    j6_log("main thread created sub thread");
+    j6::syslog(j6::logs::app, j6::log_level::info, "main thread created sub thread");
 
     for (int i = 0; i < 100; ++i)
         if (!test_floats()) break;
@@ -134,12 +134,12 @@ main(int argc, const char **argv)
     if (result != j6_status_ok)
         return result;
 
-    j6_log(message);
+    j6::syslog(j6::logs::app, j6::log_level::info, message);
 
-    j6_log("main thread waiting on sub thread");
+    j6::syslog(j6::logs::app, j6::log_level::info, "main thread waiting on sub thread");
     child_thread.join();
 
-    j6_log("main thread done, exiting");
+    j6::syslog(j6::logs::app, j6::log_level::info, "main thread done, exiting");
     return 0;
 }