Changes in / [ceafd1b:f0348c8] in mainline


Ignore:
Files:
9 deleted
8 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rceafd1b rf0348c8  
    7474        $(USPACE_PATH)/srv/locsrv/locsrv \
    7575        $(USPACE_PATH)/srv/bd/rd/rd \
    76         $(USPACE_PATH)/srv/vfs/vfs \
    77         $(USPACE_PATH)/srv/logger/logger
     76        $(USPACE_PATH)/srv/vfs/vfs
    7877
    7978ifeq ($(RDFMT),tmpfs)
    … …  
    162161        $(USPACE_PATH)/app/killall/killall \
    163162        $(USPACE_PATH)/app/loc/loc \
    164         $(USPACE_PATH)/app/logview/logview \
    165163        $(USPACE_PATH)/app/mkfat/mkfat \
    166164        $(USPACE_PATH)/app/mkexfat/mkexfat \

  • uspace/Makefile

    rceafd1b rf0348c8  
    4747        app/klog \
    4848        app/loc \
    49         app/logview \
    5049        app/lsusb \
    5150        app/mkfat \
    … …  
    7574        srv/clipboard \
    7675        srv/locsrv \
    77         srv/logger \
    7876        srv/devman \
    7977        srv/loader \

  • uspace/app/tester/Makefile

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

  • uspace/app/tester/tester.c

    rceafd1b rf0348c8  
    3939#include <stdio.h>
    4040#include <str.h>
    41 #include <io/log.h>
    4241#include "tester.h"
    4342
    … …  
    5655#include "stdio/stdio1.def"
    5756#include "stdio/stdio2.def"
    58 #include "stdio/logger1.def"
    5957#include "fault/fault1.def"
    6058#include "fault/fault2.def"
    … …  
    140138        }
    141139       
    142         log_init("tester", LVL_NOTE);
    143 
    144140        test_quiet = false;
    145141        test_argc = argc - 2;

  • uspace/app/tester/tester.h

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

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

    rceafd1b rf0348c8  
    3838#include <stdlib.h>
    3939#include <stdio.h>
    40 #include <async.h>
     40
    4141#include <io/log.h>
    42 #include <ipc/logger.h>
    43 #include <ns.h>
    4442
    45 /** Log messages are printed under this name. */
     43/** Serialization mutex for logging functions. */
     44static FIBRIL_MUTEX_INITIALIZE(log_serializer);
     45
     46/** Current log level. */
     47static log_level_t log_level;
     48
     49static FILE *log_stream;
     50
    4651static const char *log_prog_name;
    4752
    48 /** IPC session with the logger service. */
    49 static async_sess_t *logger_session;
    50 
    51 /** Maximum length of a single log message (in bytes). */
    52 #define MESSAGE_BUFFER_SIZE 4096
    53 
    54 FIBRIL_RWLOCK_INITIALIZE(current_observed_level_lock);
    55 log_level_t current_observed_level;
    56 
    57 static 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 
    78 static 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 
    106 static void cannot_use_level_changed_monitor(void)
    107 {
    108         assert(false && "not implemented yet");
    109 }
    110 
    111 static 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 
    154 static 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 }
     53/** Prefixes for individual logging levels. */
     54static 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};
    16162
    16263/** Initialize the logging system.
    … …  
    16869{
    16970        assert(level < LVL_LIMIT);
     71        log_level = level;
    17072
     73        log_stream = stdout;
    17174        log_prog_name = str_dup(prog_name);
    17275        if (log_prog_name == NULL)
    17376                return ENOMEM;
    17477
    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;
     78        return EOK;
    19279}
    19380
    … …  
    219106        assert(level < LVL_LIMIT);
    220107
    221         if (get_current_observed_level() < level) {
    222                 return;
     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);
    223119        }
    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);
    232120}
    233121

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

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

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

    rceafd1b rf0348c8  
    7474                }
    7575        }
    76         log_init(message_prefix, LVL_DEBUG);
    7776}
    7877
    … …  
    149148        }
    150149
    151         va_start(args, format);
    152         log_msgv(level, format, args);
    153         va_end(args);
    154 
    155150        fibril_mutex_unlock(&log_serializer);
    156151}
Note: See TracChangeset for help on using the changeset viewer.