Changes in / [f0348c8:ceafd1b] in mainline


Ignore:
Files:
9 added
8 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rf0348c8 rceafd1b  
    7474        $(USPACE_PATH)/srv/locsrv/locsrv \
    7575        $(USPACE_PATH)/srv/bd/rd/rd \
    76         $(USPACE_PATH)/srv/vfs/vfs
     76        $(USPACE_PATH)/srv/vfs/vfs \
     77        $(USPACE_PATH)/srv/logger/logger
    7778
    7879ifeq ($(RDFMT),tmpfs)
    … …  
    161162        $(USPACE_PATH)/app/killall/killall \
    162163        $(USPACE_PATH)/app/loc/loc \
     164        $(USPACE_PATH)/app/logview/logview \
    163165        $(USPACE_PATH)/app/mkfat/mkfat \
    164166        $(USPACE_PATH)/app/mkexfat/mkexfat \

  • uspace/Makefile

    rf0348c8 rceafd1b  
    4747        app/klog \
    4848        app/loc \
     49        app/logview \
    4950        app/lsusb \
    5051        app/mkfat \
    … …  
    7475        srv/clipboard \
    7576        srv/locsrv \
     77        srv/logger \
    7678        srv/devman \
    7779        srv/loader \

  • uspace/app/tester/Makefile

    rf0348c8 rceafd1b  
    4545        stdio/stdio1.c \
    4646        stdio/stdio2.c \
     47        stdio/logger1.c \
    4748        fault/fault1.c \
    4849        fault/fault2.c \

  • uspace/app/tester/tester.c

    rf0348c8 rceafd1b  
    3939#include <stdio.h>
    4040#include <str.h>
     41#include <io/log.h>
    4142#include "tester.h"
    4243
    … …  
    5556#include "stdio/stdio1.def"
    5657#include "stdio/stdio2.def"
     58#include "stdio/logger1.def"
    5759#include "fault/fault1.def"
    5860#include "fault/fault2.def"
    … …  
    138140        }
    139141       
     142        log_init("tester", LVL_NOTE);
     143
    140144        test_quiet = false;
    141145        test_argc = argc - 2;

  • uspace/app/tester/tester.h

    rf0348c8 rceafd1b  
    8888extern const char *test_stdio1(void);
    8989extern const char *test_stdio2(void);
     90extern const char *test_logger1(void);
    9091extern const char *test_fault1(void);
    9192extern const char *test_fault2(void);

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

    rf0348c8 rceafd1b  
    3838#include <stdlib.h>
    3939#include <stdio.h>
    40 
     40#include <async.h>
    4141#include <io/log.h>
    42 
    43 /** Serialization mutex for logging functions. */
    44 static FIBRIL_MUTEX_INITIALIZE(log_serializer);
    45 
    46 /** Current log level. */
    47 static log_level_t log_level;
    48 
    49 static FILE *log_stream;
    50 
     42#include <ipc/logger.h>
     43#include <ns.h>
     44
     45/** Log messages are printed under this name. */
    5146static const char *log_prog_name;
    5247
    53 /** Prefixes for individual logging levels. */
    54 static const char *log_level_names[] = {
    55         [LVL_FATAL] = "Fatal error",
    56         [LVL_ERROR] = "Error",
    57         [LVL_WARN] = "Warning",
    58         [LVL_NOTE] = "Note",
    59         [LVL_DEBUG] = "Debug",
    60         [LVL_DEBUG2] = "Debug2"
    61 };
     48/** IPC session with the logger service. */
     49static async_sess_t *logger_session;
     50
     51/** Maximum length of a single log message (in bytes). */
     52#define MESSAGE_BUFFER_SIZE 4096
     53
     54FIBRIL_RWLOCK_INITIALIZE(current_observed_level_lock);
     55log_level_t current_observed_level;
     56
     57static int logger_register(async_sess_t *session, const char *prog_name)
     58{
     59        async_exch_t *exchange = async_exchange_begin(session);
     60        if (exchange == NULL) {
     61                return ENOMEM;
     62        }
     63
     64        aid_t reg_msg = async_send_0(exchange, LOGGER_REGISTER, NULL);
     65        int rc = async_data_write_start(exchange, prog_name, str_size(prog_name));
     66        sysarg_t reg_msg_rc;
     67        async_wait_for(reg_msg, &reg_msg_rc);
     68
     69        async_exchange_end(exchange);
     70
     71        if (rc != EOK) {
     72                return rc;
     73        }
     74
     75        return reg_msg_rc;
     76}
     77
     78static int logger_message(async_sess_t *session, log_level_t level, const char *message)
     79{
     80        async_exch_t *exchange = async_exchange_begin(session);
     81        if (exchange == NULL) {
     82                return ENOMEM;
     83        }
     84
     85        aid_t reg_msg = async_send_1(exchange, LOGGER_MESSAGE, level, NULL);
     86        int rc = async_data_write_start(exchange, message, str_size(message));
     87        sysarg_t reg_msg_rc;
     88        async_wait_for(reg_msg, &reg_msg_rc);
     89
     90        async_exchange_end(exchange);
     91
     92        /*
     93         * Getting ENAK means no-one wants our message. That is not an
     94         * error at all.
     95         */
     96        if (rc == ENAK)
     97                rc = EOK;
     98
     99        if (rc != EOK) {
     100                return rc;
     101        }
     102
     103        return reg_msg_rc;
     104}
     105
     106static void cannot_use_level_changed_monitor(void)
     107{
     108        assert(false && "not implemented yet");
     109}
     110
     111static int observed_level_changed_monitor(void *arg)
     112{
     113        async_sess_t *monitor_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
     114        if (monitor_session == NULL) {
     115                cannot_use_level_changed_monitor();
     116                return ENOMEM;
     117        }
     118
     119        int rc = logger_register(monitor_session, log_prog_name);
     120        if (rc != EOK) {
     121                cannot_use_level_changed_monitor();
     122                return rc;
     123        }
     124
     125        async_exch_t *exchange = async_exchange_begin(monitor_session);
     126        if (exchange == NULL) {
     127                cannot_use_level_changed_monitor();
     128                return ENOMEM;
     129        }
     130
     131        while (true) {
     132                sysarg_t has_reader;
     133                sysarg_t msg_rc = async_req_0_1(exchange,
     134                    LOGGER_BLOCK_UNTIL_READER_CHANGED, &has_reader);
     135                if (msg_rc != EOK) {
     136                        cannot_use_level_changed_monitor();
     137                        break;
     138                }
     139
     140                fibril_rwlock_write_lock(&current_observed_level_lock);
     141                if ((bool) has_reader) {
     142                        current_observed_level = LVL_LIMIT;
     143                } else {
     144                        current_observed_level = LVL_NOTE;
     145                }
     146                fibril_rwlock_write_unlock(&current_observed_level_lock);
     147        }
     148
     149        async_exchange_end(exchange);
     150
     151        return EOK;
     152}
     153
     154static log_level_t get_current_observed_level(void)
     155{
     156        fibril_rwlock_read_lock(&current_observed_level_lock);
     157        log_level_t level = current_observed_level;
     158        fibril_rwlock_read_unlock(&current_observed_level_lock);
     159        return level;
     160}
    62161
    63162/** Initialize the logging system.
    … …  
    69168{
    70169        assert(level < LVL_LIMIT);
    71         log_level = level;
    72 
    73         log_stream = stdout;
     170
    74171        log_prog_name = str_dup(prog_name);
    75172        if (log_prog_name == NULL)
    76173                return ENOMEM;
    77174
    78         return EOK;
     175        logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
     176        if (logger_session == NULL) {
     177                return ENOMEM;
     178        }
     179
     180        int rc = logger_register(logger_session, log_prog_name);
     181
     182        current_observed_level = LVL_NOTE;
     183
     184        fid_t observed_level_changed_fibril = fibril_create(observed_level_changed_monitor, NULL);
     185        if (observed_level_changed_fibril == 0) {
     186                cannot_use_level_changed_monitor();
     187        } else {
     188                fibril_add_ready(observed_level_changed_fibril);
     189        }
     190
     191        return rc;
    79192}
    80193
    … …  
    106219        assert(level < LVL_LIMIT);
    107220
    108         /* Higher number means higher verbosity. */
    109         if (level <= log_level) {
    110                 fibril_mutex_lock(&log_serializer);
    111 
    112                 fprintf(log_stream, "%s: %s: ", log_prog_name,
    113                     log_level_names[level]);
    114                 vfprintf(log_stream, fmt, args);
    115                 fputc('\n', log_stream);
    116                 fflush(log_stream);
    117 
    118                 fibril_mutex_unlock(&log_serializer);
    119         }
     221        if (get_current_observed_level() < level) {
     222                return;
     223        }
     224
     225        char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
     226        if (message_buffer == NULL) {
     227                return;
     228        }
     229
     230        vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
     231        logger_message(logger_session, level, message_buffer);
    120232}
    121233

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

    rf0348c8 rceafd1b  
    4545        SERVICE_VFS        = FOURCC('v', 'f', 's', ' '),
    4646        SERVICE_LOC        = FOURCC('l', 'o', 'c', ' '),
     47        SERVICE_LOGGER     = FOURCC('l', 'o', 'g', 'g'),
    4748        SERVICE_DEVMAN     = FOURCC('d', 'e', 'v', 'n'),
    4849        SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),

  • uspace/lib/usb/src/debug.c

    rf0348c8 rceafd1b  
    7474                }
    7575        }
     76        log_init(message_prefix, LVL_DEBUG);
    7677}
    7778
    … …  
    148149        }
    149150
     151        va_start(args, format);
     152        log_msgv(level, format, args);
     153        va_end(args);
     154
    150155        fibril_mutex_unlock(&log_serializer);
    151156}
Note: See TracChangeset for help on using the changeset viewer.