Index: boot/Makefile.common =================================================================== --- boot/Makefile.common (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ boot/Makefile.common (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) @@ -165,5 +165,4 @@ $(USPACE_PATH)/app/killall/killall \ $(USPACE_PATH)/app/loc/loc \ - $(USPACE_PATH)/app/logview/logview \ $(USPACE_PATH)/app/logset/logset \ $(USPACE_PATH)/app/mkfat/mkfat \ Index: uspace/Makefile =================================================================== --- uspace/Makefile (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ uspace/Makefile (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) @@ -48,5 +48,4 @@ app/loc \ app/logset \ - app/logview \ app/mkfat \ app/mkexfat \ Index: pace/app/logview/Makefile =================================================================== --- uspace/app/logview/Makefile (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ (revision ) @@ -1,35 +1,0 @@ -# -# 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. -# - -USPACE_PREFIX = ../.. -BINARY = logview - -SOURCES = \ - logview.c - -include $(USPACE_PREFIX)/Makefile.common Index: pace/app/logview/logview.c =================================================================== --- uspace/app/logview/logview.c (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ (revision ) @@ -1,148 +1,0 @@ -/* - * 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 logview - * @{ - */ -/** @file Print logs. - */ -#include -#include -#include -#include -#include -#include -#include -#include - -#define MAX_MESSAGE_LENGTH 8192 - -static async_exch_t *init_ipc_with_server(const char *namespace) -{ - async_sess_t *logger_session = service_connect_blocking( - EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SOURCE, 0); - if (logger_session == NULL) { - fprintf(stderr, "Failed to connect to logger service.\n"); - return NULL; - } - - async_exch_t *exchange = async_exchange_begin(logger_session); - if (exchange == NULL) { - fprintf(stderr, "Failed to start exchange with logger service.\n"); - return NULL; - } - - aid_t reg_msg = async_send_0(exchange, LOGGER_CONNECT, NULL); - int rc = async_data_write_start(exchange, namespace, str_size(namespace)); - sysarg_t reg_msg_rc; - async_wait_for(reg_msg, ®_msg_rc); - - if ((rc != EOK) || (reg_msg_rc != EOK)) { - fprintf(stderr, "Failed to register with logger service: %s.\n", - str_error(rc == EOK ? (int) reg_msg_rc : rc)); - async_exchange_end(exchange); - return NULL; - } - - return exchange; -} - -static bool quit_pressed(kbd_event_t event) -{ - return (event.type == KEY_PRESS) && (event.c == 'q'); -} - -static int parse_message_level(const char *str) -{ - if (str == NULL) { - return 99; - } - char *tmp; - int result = strtol(str, &tmp, 10); - if (result < 0) { - return 0; - } - return result; -} - -int main(int argc, char *argv[]) -{ - if (argc < 2) { - fprintf(stderr, "Usage: %s [max log level]\n", argv[0]); - return 1; - } - - async_exch_t *exchange = init_ipc_with_server(argv[1]); - if (exchange == NULL) { - return 1; - } - - int display_message_level = parse_message_level(argv[2]); - - console_ctrl_t *console = console_init(stdin, stdout); - - bool terminate = false; - while (!terminate) { - ipc_call_t req_msg_data; - aid_t req_msg = async_send_0(exchange, LOGGER_GET_MESSAGE, &req_msg_data); - char message[MAX_MESSAGE_LENGTH]; - aid_t data_msg = async_data_read(exchange, &message, MAX_MESSAGE_LENGTH, NULL); - - while (true) { - sysarg_t retval; - int answer_arrived = async_wait_timeout(data_msg, &retval, 1); - if (answer_arrived == EOK) { - async_wait_for(req_msg, &retval); - if (retval == EOK) { - int level = (int) IPC_GET_ARG1(req_msg_data); - if (display_message_level >= level) { - printf("%2d: %s\n", level, message); - } - break; - } - } - - kbd_event_t kbd_event; - suseconds_t timeout = 1; - bool key_pressed = console_get_kbd_event_timeout(console, &kbd_event, &timeout); - if (key_pressed && quit_pressed(kbd_event)) { - printf("Terminating (q pressed)...\n"); - terminate = true; - break; - } - } - } - - async_exchange_end(exchange); - console_done(console); - - return 0; -} - -/** @} - */ Index: uspace/srv/logger/level.c =================================================================== --- uspace/srv/logger/level.c (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) +++ uspace/srv/logger/level.c (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) @@ -0,0 +1,63 @@ +/* + * 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 logger + * @{ + */ + +/** @file + */ + +#include +#include "logger.h" + +log_level_t default_logging_level = LVL_NOTE; +static FIBRIL_MUTEX_INITIALIZE(default_logging_level_guard); + +log_level_t get_default_logging_level(void) +{ + fibril_mutex_lock(&default_logging_level_guard); + log_level_t result = default_logging_level; + fibril_mutex_unlock(&default_logging_level_guard); + return result; +} + +int set_default_logging_level(log_level_t new_level) +{ + if (new_level >= LVL_LIMIT) + return EINVAL; + fibril_mutex_lock(&default_logging_level_guard); + default_logging_level = new_level; + fibril_mutex_unlock(&default_logging_level_guard); + return EOK; +} + +/** + * @} + */ Index: uspace/srv/logger/logger.h =================================================================== --- uspace/srv/logger/logger.h (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ uspace/srv/logger/logger.h (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) @@ -45,21 +45,10 @@ #define MAX_NAMESPACE_LENGTH 256 -typedef struct { - link_t link; - log_level_t level; - const char *message; -} log_message_t; - typedef struct logging_namespace logging_namespace_t; - -log_message_t *message_create(const char *, log_level_t); -void message_destroy(log_message_t *); logging_namespace_t *namespace_create(const char *); const char *namespace_get_name(logging_namespace_t *); void namespace_destroy(logging_namespace_t *); -logging_namespace_t *namespace_reader_attach(const char *); logging_namespace_t *namespace_writer_attach(const char *); -void namespace_reader_detach(logging_namespace_t *); void namespace_writer_detach(logging_namespace_t *); @@ -67,5 +56,4 @@ bool namespace_has_reader(logging_namespace_t *, log_level_t); void namespace_add_message(logging_namespace_t *, const char *, log_level_t); -log_message_t *namespace_get_next_message(logging_namespace_t *); log_level_t get_default_logging_level(void); Index: uspace/srv/logger/main.c =================================================================== --- uspace/srv/logger/main.c (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ uspace/srv/logger/main.c (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) @@ -104,5 +104,5 @@ static int handle_receive_message(logging_namespace_t *namespace, int level) { - bool skip_message = (level > (int)get_default_logging_level()) && !namespace_has_reader(namespace, level); + bool skip_message = !namespace_has_reader(namespace, level); if (skip_message) { /* Abort the actual message buffer transfer. */ @@ -156,90 +156,4 @@ printf(NAME "/sink: client %s terminated.\n", namespace_get_name(namespace)); namespace_writer_detach(namespace); -} - - -static logging_namespace_t *find_namespace_and_attach_reader(void) -{ - ipc_call_t call; - ipc_callid_t callid = async_get_call(&call); - - if (IPC_GET_IMETHOD(call) != LOGGER_CONNECT) { - async_answer_0(callid, EINVAL); - return NULL; - } - - void *name; - int rc = async_data_write_accept(&name, true, 1, MAX_NAMESPACE_LENGTH, 0, NULL); - - if (rc != EOK) { - async_answer_0(callid, rc); - return NULL; - } - - logging_namespace_t *result = namespace_reader_attach((const char *) name); - if (result == NULL) { - rc = ENOENT; - } - - async_answer_0(callid, rc); - - free(name); - - return result; -} - - -static int handle_send_message(logging_namespace_t *namespace, int *level) -{ - ipc_callid_t callid; - size_t size; - bool expects_data_read = async_data_read_receive(&callid, &size); - if (!expects_data_read) { - return EINVAL; - } - - log_message_t *message = namespace_get_next_message(namespace); - size_t message_len = str_size(message->message) + 1; - - if (size > message_len) { - size = message_len; - } - - async_data_read_finalize(callid, message->message, size); - - *level = (int) message->level; - message_destroy(message); - - return EOK; -} - - -static void connection_handler_source(logging_namespace_t *namespace) -{ - printf(NAME "/source: new client for %s.\n", namespace_get_name(namespace)); - - while (true) { - ipc_call_t call; - ipc_callid_t callid = async_get_call(&call); - - if (!IPC_GET_IMETHOD(call)) - break; - - int rc; - int message_level = 0; - - switch (IPC_GET_IMETHOD(call)) { - case LOGGER_GET_MESSAGE: - rc = handle_send_message(namespace, &message_level); - async_answer_1(callid, rc, message_level); - break; - default: - async_answer_0(callid, EINVAL); - break; - } - } - - printf(NAME "/source: client %s terminated.\n", namespace_get_name(namespace)); - namespace_reader_detach(namespace); } @@ -265,14 +179,4 @@ connection_handler_sink(namespace); break; - case LOGGER_INTERFACE_SOURCE: - async_answer_0(iid, EOK); - /* First call has to find existing namespace. */ - namespace = find_namespace_and_attach_reader(); - if (namespace == NULL) { - fprintf(stderr, NAME ": failed to attach client.\n"); - break; - } - connection_handler_source(namespace); - break; default: async_answer_0(iid, EINVAL); Index: uspace/srv/logger/namespace.c =================================================================== --- uspace/srv/logger/namespace.c (revision 669f5caed8b5063907bbb28370a6c9ceccd1455e) +++ uspace/srv/logger/namespace.c (revision 6e9e12bf4a25204c6bf8d4458fa8680fd08c2e59) @@ -44,40 +44,14 @@ fibril_mutex_t guard; size_t writers_count; - fibril_condvar_t reader_appeared_cv; - bool has_reader; + fibril_condvar_t level_changed_cv; FILE *logfile; - log_level_t logfile_level; + log_level_t level; const char *name; + link_t link; - prodcons_t messages; }; static FIBRIL_MUTEX_INITIALIZE(namespace_list_guard); static LIST_INITIALIZE(namespace_list); - -log_message_t *message_create(const char *name, log_level_t level) -{ - log_message_t *message = malloc(sizeof(log_message_t)); - if (message == NULL) - return NULL; - - message->message = str_dup(name); - if (message->message == NULL) { - free(message); - return NULL; - } - - message->level = level; - link_initialize(&message->link); - - return message; -} - -void message_destroy(log_message_t *message) -{ - assert(message); - free(message->message); - free(message); -} static logging_namespace_t *namespace_find_no_lock(const char *name) @@ -126,10 +100,8 @@ } - namespace->logfile_level = get_default_logging_level(); + namespace->level = get_default_logging_level(); fibril_mutex_initialize(&namespace->guard); - fibril_condvar_initialize(&namespace->reader_appeared_cv); - prodcons_initialize(&namespace->messages); - namespace->has_reader = false; + fibril_condvar_initialize(&namespace->level_changed_cv); namespace->writers_count = 0; link_initialize(&namespace->link); @@ -161,5 +133,5 @@ fibril_mutex_lock(&namespace->guard); - if (namespace->has_reader || (namespace->writers_count > 0)) { + if (namespace->writers_count > 0) { fibril_mutex_unlock(&namespace->guard); fibril_mutex_unlock(&namespace_list_guard); @@ -183,24 +155,4 @@ } -logging_namespace_t *namespace_reader_attach(const char *name) -{ - logging_namespace_t *namespace = NULL; - - fibril_mutex_lock(&namespace_list_guard); - - namespace = namespace_find_no_lock(name); - - if (namespace != NULL) { - fibril_mutex_lock(&namespace->guard); - namespace->has_reader = true; - fibril_condvar_broadcast(&namespace->reader_appeared_cv); - fibril_mutex_unlock(&namespace->guard); - } - - fibril_mutex_unlock(&namespace_list_guard); - - return namespace; -} - logging_namespace_t *namespace_writer_attach(const char *name) { @@ -224,14 +176,4 @@ } -void namespace_reader_detach(logging_namespace_t *namespace) -{ - fibril_mutex_lock(&namespace->guard); - namespace->has_reader = false; - fibril_condvar_broadcast(&namespace->reader_appeared_cv); - fibril_mutex_unlock(&namespace->guard); - - namespace_destroy_careful(namespace); -} - void namespace_writer_detach(logging_namespace_t *namespace) { @@ -247,6 +189,5 @@ { fibril_mutex_lock(&namespace->guard); - bool has_reader = namespace->has_reader - || level <= namespace->logfile_level; + bool has_reader = level <= namespace->level; fibril_mutex_unlock(&namespace->guard); return has_reader; @@ -256,9 +197,9 @@ { fibril_mutex_lock(&namespace->guard); - bool had_reader = namespace->has_reader; - while (had_reader == namespace->has_reader) { - fibril_condvar_wait(&namespace->reader_appeared_cv, &namespace->guard); - } - *has_reader_now = namespace->has_reader; + log_level_t previous_level = namespace->level; + while (previous_level == namespace->level) { + fibril_condvar_wait(&namespace->level_changed_cv, &namespace->guard); + } + *has_reader_now = true; fibril_mutex_unlock(&namespace->guard); } @@ -267,27 +208,10 @@ void namespace_add_message(logging_namespace_t *namespace, const char *message, log_level_t level) { - if (level <= get_default_logging_level()) { + if (level <= namespace->level) { printf("[%s %d]: %s\n", namespace->name, level, message); - } - if (level <= namespace->logfile_level) { fprintf(namespace->logfile, "[%d]: %s\n", level, message); fflush(namespace->logfile); - } - - fibril_mutex_lock(&namespace->guard); - if (namespace->has_reader) { - log_message_t *msg = message_create(message, level); - if (msg != NULL) { - prodcons_produce(&namespace->messages, &msg->link); - } - } - fibril_mutex_unlock(&namespace->guard); -} - -log_message_t *namespace_get_next_message(logging_namespace_t *namespace) -{ - link_t *message = prodcons_consume(&namespace->messages); - - return list_get_instance(message, log_message_t, link); + fflush(stdout); + } }