Index: uspace/lib/c/generic/io/log.c =================================================================== --- uspace/lib/c/generic/io/log.c (revision 4802dd7d8d17cb02ec8f79547ffde538bb8c6736) +++ uspace/lib/c/generic/io/log.c (revision cddcc4a3904768c1032861a518e712bd08ea3156) @@ -38,26 +38,127 @@ #include #include - +#include #include - -/** 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 +#include + +/** 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, ®_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, ®_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(¤t_observed_level_lock); + current_observed_level = LVL_LIMIT; + fibril_rwlock_write_unlock(¤t_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(¤t_observed_level_lock); + if ((bool) has_reader) { + current_observed_level = LVL_LIMIT; + } else { + current_observed_level = LVL_NOTE; + } + fibril_rwlock_write_unlock(¤t_observed_level_lock); + } + + async_exchange_end(exchange); + + return EOK; +} + +static log_level_t get_current_observed_level(void) +{ + fibril_rwlock_read_lock(¤t_observed_level_lock); + log_level_t level = current_observed_level; + fibril_rwlock_read_unlock(¤t_observed_level_lock); + return level; +} /** Initialize the logging system. @@ -69,12 +170,31 @@ { 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,10 +206,10 @@ * @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,20 +222,19 @@ * @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); } Index: uspace/lib/c/include/io/log.h =================================================================== --- uspace/lib/c/include/io/log.h (revision 4802dd7d8d17cb02ec8f79547ffde538bb8c6736) +++ uspace/lib/c/include/io/log.h (revision cddcc4a3904768c1032861a518e712bd08ea3156) @@ -36,4 +36,5 @@ #include +#include typedef enum { @@ -49,7 +50,23 @@ } 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 Index: uspace/lib/c/include/ipc/logger.h =================================================================== --- uspace/lib/c/include/ipc/logger.h (revision cddcc4a3904768c1032861a518e712bd08ea3156) +++ uspace/lib/c/include/ipc/logger.h (revision cddcc4a3904768c1032861a518e712bd08ea3156) @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2012 Vojtech Horky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup libc + * @{ + */ + +#ifndef LIBC_IPC_LOGGER_H_ +#define LIBC_IPC_LOGGER_H_ + +#include + +typedef enum { + LOGGER_REGISTER = IPC_FIRST_USER_METHOD, + LOGGER_MESSAGE, + LOGGER_BLOCK_UNTIL_READER_CHANGED +} logger_sink_request_t; + +typedef enum { + LOGGER_CONNECT = IPC_FIRST_USER_METHOD, + LOGGER_GET_MESSAGE +} logger_source_request_t; + +typedef enum { + /** Interface for servers writing to the log. */ + LOGGER_INTERFACE_SINK, + /** Interface for clients displaying the log. */ + LOGGER_INTERFACE_SOURCE +} logger_interface_t; + +#endif + +/** @} + */ Index: uspace/lib/c/include/ipc/services.h =================================================================== --- uspace/lib/c/include/ipc/services.h (revision 4802dd7d8d17cb02ec8f79547ffde538bb8c6736) +++ uspace/lib/c/include/ipc/services.h (revision cddcc4a3904768c1032861a518e712bd08ea3156) @@ -45,4 +45,5 @@ 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', ' '), Index: uspace/lib/usb/src/debug.c =================================================================== --- uspace/lib/usb/src/debug.c (revision 4802dd7d8d17cb02ec8f79547ffde538bb8c6736) +++ uspace/lib/usb/src/debug.c (revision cddcc4a3904768c1032861a518e712bd08ea3156) @@ -74,4 +74,5 @@ } } + log_init(message_prefix, LVL_DEBUG); } @@ -148,4 +149,8 @@ } + va_start(args, format); + log_msgv(level, format, args); + va_end(args); + fibril_mutex_unlock(&log_serializer); }