Changes in / [52c4264:ad78054] in mainline


Ignore:
Files:
17 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    r52c4264 rad78054  
    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)
    … …  
    170169        $(USPACE_PATH)/app/killall/killall \
    171170        $(USPACE_PATH)/app/loc/loc \
    172         $(USPACE_PATH)/app/logset/logset \
    173171        $(USPACE_PATH)/app/mkfat/mkfat \
    174172        $(USPACE_PATH)/app/mkexfat/mkexfat \

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

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

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

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

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

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

    r52c4264 rad78054  
    4747        app/klog \
    4848        app/loc \
    49         app/logset \
    5049        app/mkfat \
    5150        app/mkexfat \
    … …  
    7877        srv/clipboard \
    7978        srv/locsrv \
    80         srv/logger \
    8179        srv/devman \
    8280        srv/loader \

  • uspace/app/tester/Makefile

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

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

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

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

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

    r52c4264 rad78054  
    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 static sysarg_t default_log_id;
     43/** Serialization mutex for logging functions. */
     44static FIBRIL_MUTEX_INITIALIZE(log_serializer);
    4645
    47 /** Log messages are printed under this name. */
     46/** Current log level. */
     47static log_level_t log_level;
     48
     49static FILE *log_stream;
     50
    4851static const char *log_prog_name;
    4952
     53/** Prefixes for individual logging levels. */
    5054static const char *log_level_names[] = {
    51         "fatal",
    52         "error",
    53         "warn",
    54         "note",
    55         "debug",
    56         "debug2",
    57         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"
    5861};
    59 
    60 /** IPC session with the logger service. */
    61 static async_sess_t *logger_session;
    62 
    63 /** Maximum length of a single log message (in bytes). */
    64 #define MESSAGE_BUFFER_SIZE 4096
    65 
    66 static 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 
    97 const 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 
    105 int 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 }
    13362
    13463/** Initialize the logging system.
    … …  
    14069{
    14170        assert(level < LVL_LIMIT);
     71        log_level = level;
    14272
     73        log_stream = stdout;
    14374        log_prog_name = str_dup(prog_name);
    14475        if (log_prog_name == NULL)
    14576                return ENOMEM;
    14677
    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 
    15478        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  */
    166 log_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);
    18879}
    18980
    … …  
    19586 * @param fmt           Format string (no traling newline).
    19687 */
    197 void log_log_msg(log_t ctx, log_level_t level, const char *fmt, ...)
     88void log_msg(log_level_t level, const char *fmt, ...)
    19889{
    19990        va_list args;
    20091
    20192        va_start(args, fmt);
    202         log_log_msgv(ctx, level, fmt, args);
     93        log_msgv(level, fmt, args);
    20394        va_end(args);
    20495}
    … …  
    211102 * @param fmt           Format string (no trailing newline)
    212103 */
    213 void log_log_msgv(log_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)
    214105{
    215106        assert(level < LVL_LIMIT);
    216107
    217         char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
    218         if (message_buffer == NULL) {
    219                 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);
    220119        }
    221 
    222         vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
    223         logger_message(logger_session, ctx, level, message_buffer);
    224120}
    225121

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

    r52c4264 rad78054  
    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_t;
    54 #define PRIlogctx PRIxn
    55 #define LOG_DEFAULT ((log_t) -1)
    56 #define LOG_NO_PARENT ((log_t) 0)
    57 
    58 extern const char *log_level_str(log_level_t);
    59 extern int log_level_from_str(const char *, log_level_t *);
    60 
    6151extern int log_init(const char *, log_level_t);
    62 extern 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 
    69 extern void log_log_msg(log_t, log_level_t, const char *, ...);
    70 extern void log_log_msgv(log_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);
    7154
    7255#endif

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

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

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