Changes in / [dc5aa568:13c4fe0] in mainline


Ignore:
Files:
14 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rdc5aa568 r13c4fe0  
    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)
    … …  
    166165        $(USPACE_PATH)/app/killall/killall \
    167166        $(USPACE_PATH)/app/loc/loc \
    168         $(USPACE_PATH)/app/logset/logset \
    169167        $(USPACE_PATH)/app/mkfat/mkfat \
    170168        $(USPACE_PATH)/app/mkexfat/mkexfat \

  • kernel/genarch/include/multiboot/multiboot.h

    rdc5aa568 r13c4fe0  
    9999
    100100extern void multiboot_extract_command(char *, size_t, const char *);
    101 extern void multiboot_extract_argument(char *, size_t, const char *);
    102101extern void multiboot_info_parse(uint32_t, const multiboot_info_t *);
    103102

  • kernel/genarch/src/multiboot/multiboot.c

    rdc5aa568 r13c4fe0  
    7171}
    7272
    73 /** Extract arguments from the multiboot module command line.
    74  *
    75  * @param buf      Destination buffer (will be always NULL-terminated).
    76  * @param size     Size of destination buffer (in bytes).
    77  * @param cmd_line Input string (the command line).
    78  *
    79  */
    80 void multiboot_extract_argument(char *buf, size_t size, const char *cmd_line)
    81 {
    82         /* Start after first space. */
    83         const char *start = str_chr(cmd_line, ' ');
    84         if (start == NULL) {
    85                 str_cpy(buf, size, "");
    86                 return;
    87         }
    88 
    89         const char *end = cmd_line + str_size(cmd_line);
    90 
    91         /* Skip the space(s). */
    92         while (start != end) {
    93                 if (start[0] == ' ')
    94                         start++;
    95                 else
    96                         break;
    97         }
    98 
    99         str_ncpy(buf, size, start, (size_t) (end - start));
    100 }
    101 
    10273static void multiboot_modules(uint32_t count, multiboot_module_t *mods)
    10374{
    … …  
    11384                        multiboot_extract_command(init.tasks[init.cnt].name,
    11485                            CONFIG_TASK_NAME_BUFLEN, MULTIBOOT_PTR(mods[i].string));
    115                         multiboot_extract_argument(init.tasks[init.cnt].arguments,
    116                             CONFIG_TASK_ARGUMENTS_BUFLEN, MULTIBOOT_PTR(mods[i].string));
    117                 } else {
     86                } else
    11887                        init.tasks[init.cnt].name[0] = 0;
    119                         init.tasks[init.cnt].arguments[0] = 0;
    120                 }
    12188               
    12289                init.cnt++;

  • kernel/genarch/src/multiboot/multiboot2.c

    rdc5aa568 r13c4fe0  
    4949                multiboot_extract_command(init.tasks[init.cnt].name,
    5050                    CONFIG_TASK_NAME_BUFLEN, module->string);
    51                 multiboot_extract_argument(init.tasks[init.cnt].arguments,
    52                     CONFIG_TASK_ARGUMENTS_BUFLEN, module->string);
    5351               
    5452                init.cnt++;

  • kernel/generic/include/config.h

    rdc5aa568 r13c4fe0  
    4747#define CONFIG_INIT_TASKS        32
    4848#define CONFIG_TASK_NAME_BUFLEN  32
    49 #define CONFIG_TASK_ARGUMENTS_BUFLEN 64
    5049
    5150#ifndef __ASM__
    … …  
    5756        size_t size;
    5857        char name[CONFIG_TASK_NAME_BUFLEN];
    59         char arguments[CONFIG_TASK_ARGUMENTS_BUFLEN];
    6058} init_task_t;
    6159

  • kernel/generic/src/main/kinit.c

    rdc5aa568 r13c4fe0  
    6969#include <str.h>
    7070#include <sysinfo/stats.h>
    71 #include <sysinfo/sysinfo.h>
    7271#include <align.h>
    7372
    … …  
    180179        program_t programs[CONFIG_INIT_TASKS];
    181180       
    182         // FIXME: do not propagate arguments through sysinfo
    183         // but pass them directly to the tasks
    184         for (i = 0; i < init.cnt; i++) {
    185                 const char *arguments = init.tasks[i].arguments;
    186                 if (str_length(arguments) == 0)
    187                         continue;
    188                 if (str_length(init.tasks[i].name) == 0)
    189                         continue;
    190                 size_t arguments_size = str_size(arguments);
    191 
    192                 void *arguments_copy = malloc(arguments_size, 0);
    193                 if (arguments_copy == NULL)
    194                         continue;
    195                 memcpy(arguments_copy, arguments, arguments_size);
    196 
    197                 char item_name[CONFIG_TASK_NAME_BUFLEN + 15];
    198                 snprintf(item_name, CONFIG_TASK_NAME_BUFLEN + 15,
    199                     "init_args.%s", init.tasks[i].name);
    200 
    201                 sysinfo_set_item_data(item_name, NULL, arguments_copy, arguments_size);
    202         }
    203 
    204181        for (i = 0; i < init.cnt; i++) {
    205182                if (init.tasks[i].paddr % FRAME_SIZE) {

  • uspace/Makefile

    rdc5aa568 r13c4fe0  
    4747        app/klog \
    4848        app/loc \
    49         app/logset \
    5049        app/mkfat \
    5150        app/mkexfat \
    … …  
    7574        srv/clipboard \
    7675        srv/locsrv \
    77         srv/logger \
    7876        srv/devman \
    7977        srv/loader \

  • uspace/app/tester/Makefile

    rdc5aa568 r13c4fe0  
    4545        stdio/stdio1.c \
    4646        stdio/stdio2.c \
    47         stdio/logger1.c \
    48         stdio/logger2.c \
    4947        fault/fault1.c \
    5048        fault/fault2.c \

  • uspace/app/tester/tester.c

    rdc5aa568 r13c4fe0  
    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"
    59 #include "stdio/logger2.def"
    6057#include "fault/fault1.def"
    6158#include "fault/fault2.def"
    … …  
    141138        }
    142139       
    143         log_init("tester", LVL_NOTE);
    144 
    145140        test_quiet = false;
    146141        test_argc = argc - 2;

  • uspace/app/tester/tester.h

    rdc5aa568 r13c4fe0  
    8888extern const char *test_stdio1(void);
    8989extern const char *test_stdio2(void);
    90 extern const char *test_logger1(void);
    91 extern const char *test_logger2(void);
    9290extern const char *test_fault1(void);
    9391extern const char *test_fault2(void);

  • uspace/lib/c/Makefile

    rdc5aa568 r13c4fe0  
    9797        generic/io/printf.c \
    9898        generic/io/log.c \
    99         generic/io/logctl.c \
    10099        generic/io/klog.c \
    101100        generic/io/snprintf.c \

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

    rdc5aa568 r13c4fe0  
    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
     53/** Prefixes for individual logging levels. */
    4854static const char *log_level_names[] = {
    49         "fatal",
    50         "error",
    51         "warn",
    52         "note",
    53         "debug",
    54         "debug2",
    55         NULL
     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"
    5661};
    57 
    58 /** IPC session with the logger service. */
    59 static async_sess_t *logger_session;
    60 
    61 /** Maximum length of a single log message (in bytes). */
    62 #define MESSAGE_BUFFER_SIZE 4096
    63 
    64 FIBRIL_RWLOCK_INITIALIZE(current_observed_level_lock);
    65 log_level_t current_observed_level;
    66 
    67 static int logger_register(async_sess_t *session, const char *prog_name)
    68 {
    69         async_exch_t *exchange = async_exchange_begin(session);
    70         if (exchange == NULL) {
    71                 return ENOMEM;
    72         }
    73 
    74         aid_t reg_msg = async_send_0(exchange, LOGGER_REGISTER, NULL);
    75         int rc = async_data_write_start(exchange, prog_name, str_size(prog_name));
    76         sysarg_t reg_msg_rc;
    77         async_wait_for(reg_msg, &reg_msg_rc);
    78 
    79         async_exchange_end(exchange);
    80 
    81         if (rc != EOK) {
    82                 return rc;
    83         }
    84 
    85         return reg_msg_rc;
    86 }
    87 
    88 static int logger_message(async_sess_t *session, log_context_t ctx, log_level_t level, const char *message)
    89 {
    90         async_exch_t *exchange = async_exchange_begin(session);
    91         if (exchange == NULL) {
    92                 return ENOMEM;
    93         }
    94 
    95         aid_t reg_msg = async_send_2(exchange, LOGGER_MESSAGE,
    96             ctx, level, NULL);
    97         int rc = async_data_write_start(exchange, message, str_size(message));
    98         sysarg_t reg_msg_rc;
    99         async_wait_for(reg_msg, &reg_msg_rc);
    100 
    101         async_exchange_end(exchange);
    102 
    103         /*
    104          * Getting ENAK means no-one wants our message. That is not an
    105          * error at all.
    106          */
    107         if (rc == ENAK)
    108                 rc = EOK;
    109 
    110         if (rc != EOK) {
    111                 return rc;
    112         }
    113 
    114         return reg_msg_rc;
    115 }
    116 
    117 static void cannot_use_level_changed_monitor(void)
    118 {
    119         fibril_rwlock_write_lock(&current_observed_level_lock);
    120         current_observed_level = LVL_LIMIT;
    121         fibril_rwlock_write_unlock(&current_observed_level_lock);
    122 }
    123 
    124 static int observed_level_changed_monitor(void *arg)
    125 {
    126         async_sess_t *monitor_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
    127         if (monitor_session == NULL) {
    128                 cannot_use_level_changed_monitor();
    129                 return ENOMEM;
    130         }
    131 
    132         int rc = logger_register(monitor_session, log_prog_name);
    133         if (rc != EOK) {
    134                 cannot_use_level_changed_monitor();
    135                 return rc;
    136         }
    137 
    138         async_exch_t *exchange = async_exchange_begin(monitor_session);
    139         if (exchange == NULL) {
    140                 cannot_use_level_changed_monitor();
    141                 return ENOMEM;
    142         }
    143 
    144         while (true) {
    145                 sysarg_t has_reader;
    146                 sysarg_t msg_rc = async_req_0_1(exchange,
    147                     LOGGER_BLOCK_UNTIL_READER_CHANGED, &has_reader);
    148                 if (msg_rc != EOK) {
    149                         cannot_use_level_changed_monitor();
    150                         break;
    151                 }
    152 
    153                 fibril_rwlock_write_lock(&current_observed_level_lock);
    154                 if ((bool) has_reader) {
    155                         current_observed_level = LVL_LIMIT;
    156                 } else {
    157                         current_observed_level = LVL_NOTE;
    158                 }
    159                 fibril_rwlock_write_unlock(&current_observed_level_lock);
    160         }
    161 
    162         async_exchange_end(exchange);
    163 
    164         return EOK;
    165 }
    166 
    167 static log_level_t get_current_observed_level(void)
    168 {
    169         fibril_rwlock_read_lock(&current_observed_level_lock);
    170         log_level_t level = current_observed_level;
    171         fibril_rwlock_read_unlock(&current_observed_level_lock);
    172         return level;
    173 }
    174 
    175 const char *log_level_str(log_level_t level)
    176 {
    177         if (level >= LVL_LIMIT)
    178                 return "unknown";
    179         else
    180                 return log_level_names[level];
    181 }
    182 
    183 int log_level_from_str(const char *name, log_level_t *level_out)
    184 {
    185         log_level_t level = LVL_FATAL;
    186 
    187         while (log_level_names[level] != NULL) {
    188                 if (str_cmp(name, log_level_names[level]) == 0) {
    189                         if (level_out != NULL)
    190                                 *level_out = level;
    191                         return EOK;
    192                 }
    193                 level++;
    194         }
    195 
    196         /* Maybe user specified number directly. */
    197         char *end_ptr;
    198         int level_int = strtol(name, &end_ptr, 0);
    199         if ((end_ptr == name) || (str_length(end_ptr) != 0))
    200                 return EINVAL;
    201         if (level_int < 0)
    202                 return ERANGE;
    203         if (level_int >= (int) LVL_LIMIT)
    204                 return ERANGE;
    205 
    206         if (level_out != NULL)
    207                 *level_out = (log_level_t) level_int;
    208 
    209         return EOK;
    210 }
    21162
    21263/** Initialize the logging system.
    … …  
    21869{
    21970        assert(level < LVL_LIMIT);
     71        log_level = level;
    22072
     73        log_stream = stdout;
    22174        log_prog_name = str_dup(prog_name);
    22275        if (log_prog_name == NULL)
    22376                return ENOMEM;
    22477
    225         logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_SINK, 0);
    226         if (logger_session == NULL) {
    227                 return ENOMEM;
    228         }
    229 
    230         int rc = logger_register(logger_session, log_prog_name);
    231 
    232         current_observed_level = LVL_NOTE;
    233 
    234         fid_t observed_level_changed_fibril = fibril_create(observed_level_changed_monitor, NULL);
    235         if (observed_level_changed_fibril == 0) {
    236                 cannot_use_level_changed_monitor();
    237         } else {
    238                 fibril_add_ready(observed_level_changed_fibril);
    239         }
    240 
    241         return rc;
    242 }
    243 
    244 /** Create logging context.
    245  *
    246  * This function always returns a valid context.
    247  */
    248 log_context_t log_context_create(const char *name)
    249 {
    250         async_exch_t *exchange = async_exchange_begin(logger_session);
    251         if (exchange == NULL)
    252                 return LOG_CONTEXT_DEFAULT;
    253 
    254         ipc_call_t answer;
    255         aid_t reg_msg = async_send_0(exchange, LOGGER_CREATE_CONTEXT, &answer);
    256         int rc = async_data_write_start(exchange, name, str_size(name));
    257         sysarg_t reg_msg_rc;
    258         async_wait_for(reg_msg, &reg_msg_rc);
    259 
    260         async_exchange_end(exchange);
    261 
    262         if ((rc != EOK) || (reg_msg_rc != EOK))
    263                 return LOG_CONTEXT_DEFAULT;
    264 
    265         return IPC_GET_ARG1(answer);
    266 }
    267 
    268 bool _log_shall_record(log_context_t context, log_level_t level)
    269 {
    270         return get_current_observed_level() >= level;
     78        return EOK;
    27179}
    27280
    … …  
    27886 * @param fmt           Format string (no traling newline).
    27987 */
    280 void _log_ctx_msg(log_context_t ctx, log_level_t level, const char *fmt, ...)
     88void log_msg(log_level_t level, const char *fmt, ...)
    28189{
    28290        va_list args;
    28391
    28492        va_start(args, fmt);
    285         _log_ctx_msgv(ctx, level, fmt, args);
     93        log_msgv(level, fmt, args);
    28694        va_end(args);
    28795}
    … …  
    294102 * @param fmt           Format string (no trailing newline)
    295103 */
    296 void _log_ctx_msgv(log_context_t ctx, log_level_t level, const char *fmt, va_list args)
     104void log_msgv(log_level_t level, const char *fmt, va_list args)
    297105{
    298106        assert(level < LVL_LIMIT);
    299107
    300         if (get_current_observed_level() < level) {
    301                 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);
    302119        }
    303 
    304         char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
    305         if (message_buffer == NULL) {
    306                 return;
    307         }
    308 
    309         vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
    310         logger_message(logger_session, ctx, level, message_buffer);
    311120}
    312121

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

    rdc5aa568 r13c4fe0  
    3636
    3737#include <stdarg.h>
    38 #include <inttypes.h>
    39 #include <bool.h>
    4038
    4139typedef enum {
    … …  
    5149} log_level_t;
    5250
    53 typedef sysarg_t log_context_t;
    54 #define PRIlogctx PRIxn
    55 #define LOG_CONTEXT_DEFAULT 0
    56 
    57 extern const char *log_level_str(log_level_t);
    58 extern int log_level_from_str(const char *, log_level_t *);
    59 
    60 extern bool _log_shall_record(log_context_t, log_level_t);
    6151extern int log_init(const char *, log_level_t);
    62 
    63 extern log_context_t log_context_create(const char *);
    64 
    65 #define log_ctx_msg(context, level, format, ...) \
    66         do { \
    67                 if (_log_shall_record((context), (level))) { \
    68                         _log_ctx_msg((context), (level), format, ##__VA_ARGS__); \
    69                 } \
    70         } while (false)
    71 
    72 #define log_ctx_msgv(context, level, format, args) \
    73         do { \
    74                 if (_log_shall_record((context), (level))) { \
    75                         _log_ctx_msgv((context), (level), format, args); \
    76                 } \
    77         } while (false)
    78 
    79 #define log_msg(level, format, ...) \
    80         log_ctx_msg(LOG_CONTEXT_DEFAULT, (level), (format), ##__VA_ARGS__)
    81 #define log_msgv(level, format, args) \
    82         log_ctx_msgv(LOG_CONTEXT_DEFAULT, (level), (format), (args))
    83 
    84 extern void _log_ctx_msg(log_context_t, log_level_t, const char *, ...);
    85 extern void _log_ctx_msgv(log_context_t, log_level_t, const char *, va_list);
     52extern void log_msg(log_level_t, const char *, ...);
     53extern void log_msgv(log_level_t, const char *, va_list);
    8654
    8755#endif

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

    rdc5aa568 r13c4fe0  
    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

    rdc5aa568 r13c4fe0  
    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.