Changes in / [c8444d8:5882487] in mainline

Files:

• boot/Makefile.common (modified) (2 diffs)
• uspace/Makefile (modified) (2 diffs)
• uspace/app/logset/Makefile (added)
• uspace/app/logset/main.c (added)
• uspace/app/tester/Makefile (modified) (1 diff)
• uspace/app/tester/stdio/logger1.c (added)
• uspace/app/tester/stdio/logger1.def (added)
• uspace/app/tester/tester.c (modified) (3 diffs)
• uspace/app/tester/tester.h (modified) (1 diff)
• uspace/lib/c/Makefile (modified) (1 diff)
• uspace/lib/c/generic/io/log.c (modified) (4 diffs)
• uspace/lib/c/generic/io/logctl.c (added)
• uspace/lib/c/include/io/log.h (modified) (2 diffs)
• uspace/lib/c/include/io/logctl.h (added)
• uspace/lib/c/include/ipc/logger.h (added)
• uspace/lib/c/include/ipc/services.h (modified) (1 diff)
• uspace/lib/usb/src/debug.c (modified) (2 diffs)
• uspace/srv/logger/Makefile (added)
• uspace/srv/logger/level.c (added)
• uspace/srv/logger/logger.h (added)
• uspace/srv/logger/main.c (added)
• uspace/srv/logger/namespace.c (added)

boot/Makefile.common

@@ -74 +74 @@
         $(USPACE_PATH)/srv/locsrv/locsrv \
         $(USPACE_PATH)/srv/bd/rd/rd \
-        $(USPACE_PATH)/srv/vfs/vfs
+        $(USPACE_PATH)/srv/vfs/vfs \
+        $(USPACE_PATH)/srv/logger/logger
 
 ifeq ($(RDFMT),tmpfs)
@@ -165 +166 @@
         $(USPACE_PATH)/app/killall/killall \
         $(USPACE_PATH)/app/loc/loc \
+        $(USPACE_PATH)/app/logset/logset \
         $(USPACE_PATH)/app/mkfat/mkfat \
         $(USPACE_PATH)/app/mkexfat/mkexfat \

uspace/Makefile

@@ -47 +47 @@
         app/klog \
         app/loc \
+        app/logset \
         app/mkfat \
         app/mkexfat \
@@ -74 +75 @@
         srv/clipboard \
         srv/locsrv \
+        srv/logger \
         srv/devman \
         srv/loader \

uspace/app/tester/Makefile

@@ -45 +45 @@
         stdio/stdio1.c \
         stdio/stdio2.c \
+        stdio/logger1.c \
         fault/fault1.c \
         fault/fault2.c \

uspace/app/tester/tester.c

@@ -39 +39 @@
 #include <stdio.h>
 #include <str.h>
+#include <io/log.h>
 #include "tester.h"
 
@@ -55 +56 @@
 #include "stdio/stdio1.def"
 #include "stdio/stdio2.def"
+#include "stdio/logger1.def"
 #include "fault/fault1.def"
 #include "fault/fault2.def"
@@ -138 +140 @@
         }
         
+        log_init("tester", LVL_NOTE);
+
         test_quiet = false;
         test_argc = argc - 2;

uspace/app/tester/tester.h

@@ -88 +88 @@
 extern const char *test_stdio1(void);
 extern const char *test_stdio2(void);
+extern const char *test_logger1(void);
 extern const char *test_fault1(void);
 extern const char *test_fault2(void);

uspace/lib/c/Makefile

@@ -97 +97 @@
         generic/io/printf.c \
         generic/io/log.c \
+        generic/io/logctl.c \
         generic/io/klog.c \
         generic/io/snprintf.c \

uspace/lib/c/generic/io/log.c

@@ -38 +38 @@
 #include <stdlib.h>
 #include <stdio.h>
-
+#include <async.h>
 #include <io/log.h>
-
-/** Serialization mutex for logging functions. */
-static FIBRIL_MUTEX_INITIALIZE(log_serializer);
-
-/** Current log level. */
-static log_level_t log_level;
-
-static FILE *log_stream;
-
+#include <ipc/logger.h>
+#include <ns.h>
+
+/** Log messages are printed under this name. */
 static const char *log_prog_name;
 
-/** Prefixes for individual logging levels. */
-static const char *log_level_names[] = {
-        [LVL_FATAL] = "Fatal error",
-        [LVL_ERROR] = "Error",
-        [LVL_WARN] = "Warning",
-        [LVL_NOTE] = "Note",
-        [LVL_DEBUG] = "Debug",
-        [LVL_DEBUG2] = "Debug2"
-};
+/** IPC session with the logger service. */
+static async_sess_t *logger_session;
+
+/** Maximum length of a single log message (in bytes). */
+#define MESSAGE_BUFFER_SIZE 4096
+
+FIBRIL_RWLOCK_INITIALIZE(current_observed_level_lock);
+log_level_t current_observed_level;
+
+static int logger_register(async_sess_t *session, const char *prog_name)
+{
+        async_exch_t *exchange = async_exchange_begin(session);
+        if (exchange == NULL) {
+                return ENOMEM;
+        }
+
+        aid_t reg_msg = async_send_0(exchange, LOGGER_REGISTER, NULL);
+        int rc = async_data_write_start(exchange, prog_name, str_size(prog_name));
+        sysarg_t reg_msg_rc;
+        async_wait_for(reg_msg, &reg_msg_rc);
+
+        async_exchange_end(exchange);
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        return reg_msg_rc;
+}
+
+static int logger_message(async_sess_t *session, log_level_t level, const char *message)
+{
+        async_exch_t *exchange = async_exchange_begin(session);
+        if (exchange == NULL) {
+                return ENOMEM;
+        }
+
+        aid_t reg_msg = async_send_1(exchange, LOGGER_MESSAGE, level, NULL);
+        int rc = async_data_write_start(exchange, message, str_size(message));
+        sysarg_t reg_msg_rc;
+        async_wait_for(reg_msg, &reg_msg_rc);
+
+        async_exchange_end(exchange);
+
+        /*
+         * Getting ENAK means no-one wants our message. That is not an
+         * error at all.
+         */
+        if (rc == ENAK)
+                rc = EOK;
+
+        if (rc != EOK) {
+                return rc;
+        }
+
+        return reg_msg_rc;
+}
+
+static void cannot_use_level_changed_monitor(void)
+{
+        fibril_rwlock_write_lock(&current_observed_level_lock);
+        current_observed_level = LVL_LIMIT;
+        fibril_rwlock_write_unlock(&current_observed_level_lock);
+}
+
+static int observed_level_changed_monitor(void *arg)
+{
+        async_sess_t *monitor_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
+        if (monitor_session == NULL) {
+                cannot_use_level_changed_monitor();
+                return ENOMEM;
+        }
+
+        int rc = logger_register(monitor_session, log_prog_name);
+        if (rc != EOK) {
+                cannot_use_level_changed_monitor();
+                return rc;
+        }
+
+        async_exch_t *exchange = async_exchange_begin(monitor_session);
+        if (exchange == NULL) {
+                cannot_use_level_changed_monitor();
+                return ENOMEM;
+        }
+
+        while (true) {
+                sysarg_t has_reader;
+                sysarg_t msg_rc = async_req_0_1(exchange,
+                    LOGGER_BLOCK_UNTIL_READER_CHANGED, &has_reader);
+                if (msg_rc != EOK) {
+                        cannot_use_level_changed_monitor();
+                        break;
+                }
+
+                fibril_rwlock_write_lock(&current_observed_level_lock);
+                if ((bool) has_reader) {
+                        current_observed_level = LVL_LIMIT;
+                } else {
+                        current_observed_level = LVL_NOTE;
+                }
+                fibril_rwlock_write_unlock(&current_observed_level_lock);
+        }
+
+        async_exchange_end(exchange);
+
+        return EOK;
+}
+
+static log_level_t get_current_observed_level(void)
+{
+        fibril_rwlock_read_lock(&current_observed_level_lock);
+        log_level_t level = current_observed_level;
+        fibril_rwlock_read_unlock(&current_observed_level_lock);
+        return level;
+}
 
 /** Initialize the logging system.
@@ -69 +170 @@
 {
         assert(level < LVL_LIMIT);
-        log_level = level;
-
-        log_stream = stdout;
+
         log_prog_name = str_dup(prog_name);
         if (log_prog_name == NULL)
                 return ENOMEM;
 
-        return EOK;
+        logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
+        if (logger_session == NULL) {
+                return ENOMEM;
+        }
+
+        int rc = logger_register(logger_session, log_prog_name);
+
+        current_observed_level = LVL_NOTE;
+
+        fid_t observed_level_changed_fibril = fibril_create(observed_level_changed_monitor, NULL);
+        if (observed_level_changed_fibril == 0) {
+                cannot_use_level_changed_monitor();
+        } else {
+                fibril_add_ready(observed_level_changed_fibril);
+        }
+
+        return rc;
+}
+
+bool __log_shall_record(log_level_t level)
+{
+        return get_current_observed_level() >= level;
 }
 
@@ -86 +206 @@
  * @param fmt           Format string (no traling newline).
  */
-void log_msg(log_level_t level, const char *fmt, ...)
+void __log_msg(log_level_t level, const char *fmt, ...)
 {
         va_list args;
 
         va_start(args, fmt);
-        log_msgv(level, fmt, args);
+        __log_msgv(level, fmt, args);
         va_end(args);
 }
@@ -102 +222 @@
  * @param fmt           Format string (no trailing newline)
  */
-void log_msgv(log_level_t level, const char *fmt, va_list args)
+void __log_msgv(log_level_t level, const char *fmt, va_list args)
 {
         assert(level < LVL_LIMIT);
 
-        /* Higher number means higher verbosity. */
-        if (level <= log_level) {
-                fibril_mutex_lock(&log_serializer);
-
-                fprintf(log_stream, "%s: %s: ", log_prog_name,
-                    log_level_names[level]);
-                vfprintf(log_stream, fmt, args);
-                fputc('\n', log_stream);
-                fflush(log_stream);
-
-                fibril_mutex_unlock(&log_serializer);
-        }
+        if (get_current_observed_level() < level) {
+                return;
+        }
+
+        char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
+        if (message_buffer == NULL) {
+                return;
+        }
+
+        vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
+        logger_message(logger_session, level, message_buffer);
 }
 

uspace/lib/c/include/io/log.h

@@ -36 +36 @@
 
 #include <stdarg.h>
+#include <bool.h>
 
 typedef enum {
@@ -49 +50 @@
 } log_level_t;
 
+extern bool __log_shall_record(log_level_t);
 extern int log_init(const char *, log_level_t);
-extern void log_msg(log_level_t, const char *, ...);
-extern void log_msgv(log_level_t, const char *, va_list);
+
+#define log_msg(level, format, ...) \
+        do { \
+                if (__log_shall_record((level))) { \
+                        __log_msg(level, format, ##__VA_ARGS__); \
+                } \
+        } while (false)
+
+#define log_msgv(level, format, args) \
+        do { \
+                if (__log_shall_record((level))) { \
+                        __log_msgv(level, format, args); \
+                } \
+        } while (false)
+
+extern void __log_msg(log_level_t, const char *, ...);
+extern void __log_msgv(log_level_t, const char *, va_list);
 
 #endif

uspace/lib/c/include/ipc/services.h

@@ -45 +45 @@
         SERVICE_VFS        = FOURCC('v', 'f', 's', ' '),
         SERVICE_LOC        = FOURCC('l', 'o', 'c', ' '),
+        SERVICE_LOGGER     = FOURCC('l', 'o', 'g', 'g'),
         SERVICE_DEVMAN     = FOURCC('d', 'e', 'v', 'n'),
         SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),

uspace/lib/usb/src/debug.c

@@ -74 +74 @@
                 }
         }
+        log_init(message_prefix, LVL_DEBUG);
 }
 
@@ -148 +149 @@
         }
 
+        va_start(args, format);
+        log_msgv(level, format, args);
+        va_end(args);
+
         fibril_mutex_unlock(&log_serializer);
 }