Changes in / [ad78054:52c4264] in mainline


Ignore:
Files:
17 added
15 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rad78054 r52c4264  
    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)
    … …  
    169170        $(USPACE_PATH)/app/killall/killall \
    170171        $(USPACE_PATH)/app/loc/loc \
     172        $(USPACE_PATH)/app/logset/logset \
    171173        $(USPACE_PATH)/app/mkfat/mkfat \
    172174        $(USPACE_PATH)/app/mkexfat/mkexfat \

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

    rad78054 r52c4264  
    9999
    100100extern void multiboot_extract_command(char *, size_t, const char *);
     101extern void multiboot_extract_argument(char *, size_t, const char *);
    101102extern void multiboot_info_parse(uint32_t, const multiboot_info_t *);
    102103

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

    rad78054 r52c4264  
    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 */
     80void 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
    73102static void multiboot_modules(uint32_t count, multiboot_module_t *mods)
    74103{
    … …  
    84113                        multiboot_extract_command(init.tasks[init.cnt].name,
    85114                            CONFIG_TASK_NAME_BUFLEN, MULTIBOOT_PTR(mods[i].string));
    86                 } else
     115                        multiboot_extract_argument(init.tasks[init.cnt].arguments,
     116                            CONFIG_TASK_ARGUMENTS_BUFLEN, MULTIBOOT_PTR(mods[i].string));
     117                } else {
    87118                        init.tasks[init.cnt].name[0] = 0;
     119                        init.tasks[init.cnt].arguments[0] = 0;
     120                }
    88121               
    89122                init.cnt++;

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

    rad78054 r52c4264  
    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);
    5153               
    5254                init.cnt++;

  • kernel/generic/include/config.h

    rad78054 r52c4264  
    4747#define CONFIG_INIT_TASKS        32
    4848#define CONFIG_TASK_NAME_BUFLEN  32
     49#define CONFIG_TASK_ARGUMENTS_BUFLEN 64
    4950
    5051#ifndef __ASM__
    … …  
    5657        size_t size;
    5758        char name[CONFIG_TASK_NAME_BUFLEN];
     59        char arguments[CONFIG_TASK_ARGUMENTS_BUFLEN];
    5860} init_task_t;
    5961

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

    rad78054 r52c4264  
    6969#include <str.h>
    7070#include <sysinfo/stats.h>
     71#include <sysinfo/sysinfo.h>
    7172#include <align.h>
    7273
    … …  
    179180        program_t programs[CONFIG_INIT_TASKS];
    180181       
     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
    181204        for (i = 0; i < init.cnt; i++) {
    182205                if (init.tasks[i].paddr % FRAME_SIZE) {

  • uspace/Makefile

    rad78054 r52c4264  
    4747        app/klog \
    4848        app/loc \
     49        app/logset \
    4950        app/mkfat \
    5051        app/mkexfat \
    … …  
    7778        srv/clipboard \
    7879        srv/locsrv \
     80        srv/logger \
    7981        srv/devman \
    8082        srv/loader \

  • uspace/app/tester/Makefile

    rad78054 r52c4264  
    4545        stdio/stdio1.c \
    4646        stdio/stdio2.c \
     47        stdio/logger1.c \
     48        stdio/logger2.c \
    4749        fault/fault1.c \
    4850        fault/fault2.c \

  • uspace/app/tester/tester.c

    rad78054 r52c4264  
    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"
     59#include "stdio/logger2.def"
    5760#include "fault/fault1.def"
    5861#include "fault/fault2.def"
    … …  
    138141        }
    139142       
     143        log_init("tester", LVL_NOTE);
     144
    140145        test_quiet = false;
    141146        test_argc = argc - 2;

  • uspace/app/tester/tester.h

    rad78054 r52c4264  
    8888extern const char *test_stdio1(void);
    8989extern const char *test_stdio2(void);
     90extern const char *test_logger1(void);
     91extern const char *test_logger2(void);
    9092extern const char *test_fault1(void);
    9193extern const char *test_fault2(void);

  • uspace/lib/c/Makefile

    rad78054 r52c4264  
    100100        generic/io/printf.c \
    101101        generic/io/log.c \
     102        generic/io/logctl.c \
    102103        generic/io/klog.c \
    103104        generic/io/snprintf.c \

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

    rad78054 r52c4264  
    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
     45static sysarg_t default_log_id;
     46
     47/** Log messages are printed under this name. */
    5148static const char *log_prog_name;
    5249
    53 /** Prefixes for individual logging levels. */
    5450static 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"
     51        "fatal",
     52        "error",
     53        "warn",
     54        "note",
     55        "debug",
     56        "debug2",
     57        NULL
    6158};
     59
     60/** IPC session with the logger service. */
     61static async_sess_t *logger_session;
     62
     63/** Maximum length of a single log message (in bytes). */
     64#define MESSAGE_BUFFER_SIZE 4096
     65
     66static int logger_message(async_sess_t *session, log_t log, log_level_t level, const char *message)
     67{
     68        async_exch_t *exchange = async_exchange_begin(session);
     69        if (exchange == NULL) {
     70                return ENOMEM;
     71        }
     72        if (log == LOG_DEFAULT)
     73                log = default_log_id;
     74
     75        aid_t reg_msg = async_send_2(exchange, LOGGER_WRITER_MESSAGE,
     76            log, level, NULL);
     77        int rc = async_data_write_start(exchange, message, str_size(message));
     78        sysarg_t reg_msg_rc;
     79        async_wait_for(reg_msg, &reg_msg_rc);
     80
     81        async_exchange_end(exchange);
     82
     83        /*
     84         * Getting ENAK means no-one wants our message. That is not an
     85         * error at all.
     86         */
     87        if (rc == ENAK)
     88                rc = EOK;
     89
     90        if (rc != EOK) {
     91                return rc;
     92        }
     93
     94        return reg_msg_rc;
     95}
     96
     97const char *log_level_str(log_level_t level)
     98{
     99        if (level >= LVL_LIMIT)
     100                return "unknown";
     101        else
     102                return log_level_names[level];
     103}
     104
     105int log_level_from_str(const char *name, log_level_t *level_out)
     106{
     107        log_level_t level = LVL_FATAL;
     108
     109        while (log_level_names[level] != NULL) {
     110                if (str_cmp(name, log_level_names[level]) == 0) {
     111                        if (level_out != NULL)
     112                                *level_out = level;
     113                        return EOK;
     114                }
     115                level++;
     116        }
     117
     118        /* Maybe user specified number directly. */
     119        char *end_ptr;
     120        int level_int = strtol(name, &end_ptr, 0);
     121        if ((end_ptr == name) || (str_length(end_ptr) != 0))
     122                return EINVAL;
     123        if (level_int < 0)
     124                return ERANGE;
     125        if (level_int >= (int) LVL_LIMIT)
     126                return ERANGE;
     127
     128        if (level_out != NULL)
     129                *level_out = (log_level_t) level_int;
     130
     131        return EOK;
     132}
    62133
    63134/** Initialize the logging system.
    … …  
    69140{
    70141        assert(level < LVL_LIMIT);
    71         log_level = level;
    72 
    73         log_stream = stdout;
     142
    74143        log_prog_name = str_dup(prog_name);
    75144        if (log_prog_name == NULL)
    76145                return ENOMEM;
    77146
     147        logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_WRITER, 0);
     148        if (logger_session == NULL) {
     149                return ENOMEM;
     150        }
     151
     152        default_log_id = log_create(prog_name, LOG_NO_PARENT);
     153
    78154        return EOK;
     155}
     156
     157/** Create a new (sub-) log.
     158 *
     159 * This function always returns a valid log_t. In case of errors,
     160 * @c parent is returned and errors are silently ignored.
     161 *
     162 * @param name Log name under which message will be reported (appended to parents name).
     163 * @param parent Parent log.
     164 * @return Opaque identifier of the newly created log.
     165 */
     166log_t log_create(const char *name, log_t parent)
     167{
     168        async_exch_t *exchange = async_exchange_begin(logger_session);
     169        if (exchange == NULL)
     170                return parent;
     171
     172        if (parent == LOG_DEFAULT)
     173                parent = default_log_id;
     174
     175        ipc_call_t answer;
     176        aid_t reg_msg = async_send_1(exchange, LOGGER_WRITER_CREATE_LOG,
     177            parent, &answer);
     178        int rc = async_data_write_start(exchange, name, str_size(name));
     179        sysarg_t reg_msg_rc;
     180        async_wait_for(reg_msg, &reg_msg_rc);
     181
     182        async_exchange_end(exchange);
     183
     184        if ((rc != EOK) || (reg_msg_rc != EOK))
     185                return parent;
     186
     187        return IPC_GET_ARG1(answer);
    79188}
    80189
    … …  
    86195 * @param fmt           Format string (no traling newline).
    87196 */
    88 void log_msg(log_level_t level, const char *fmt, ...)
     197void log_log_msg(log_t ctx, log_level_t level, const char *fmt, ...)
    89198{
    90199        va_list args;
    91200
    92201        va_start(args, fmt);
    93         log_msgv(level, fmt, args);
     202        log_log_msgv(ctx, level, fmt, args);
    94203        va_end(args);
    95204}
    … …  
    102211 * @param fmt           Format string (no trailing newline)
    103212 */
    104 void log_msgv(log_level_t level, const char *fmt, va_list args)
     213void log_log_msgv(log_t ctx, log_level_t level, const char *fmt, va_list args)
    105214{
    106215        assert(level < LVL_LIMIT);
    107216
    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         }
     217        char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
     218        if (message_buffer == NULL) {
     219                return;
     220        }
     221
     222        vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
     223        logger_message(logger_session, ctx, level, message_buffer);
    120224}
    121225

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

    rad78054 r52c4264  
    3636
    3737#include <stdarg.h>
     38#include <inttypes.h>
     39#include <bool.h>
    3840
    3941typedef enum {
    … …  
    4951} log_level_t;
    5052
     53typedef sysarg_t log_t;
     54#define PRIlogctx PRIxn
     55#define LOG_DEFAULT ((log_t) -1)
     56#define LOG_NO_PARENT ((log_t) 0)
     57
     58extern const char *log_level_str(log_level_t);
     59extern int log_level_from_str(const char *, log_level_t *);
     60
    5161extern int log_init(const char *, log_level_t);
    52 extern void log_msg(log_level_t, const char *, ...);
    53 extern void log_msgv(log_level_t, const char *, va_list);
     62extern log_t log_create(const char *, log_t);
     63
     64#define log_msg(level, format, ...) \
     65        log_log_msg(LOG_DEFAULT, (level), (format), ##__VA_ARGS__)
     66#define log_msgv(level, format, args) \
     67        log_log_msgv(LOG_DEFAULT, (level), (format), (args))
     68
     69extern void log_log_msg(log_t, log_level_t, const char *, ...);
     70extern void log_log_msgv(log_t, log_level_t, const char *, va_list);
    5471
    5572#endif

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

    rad78054 r52c4264  
    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

    rad78054 r52c4264  
    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.