Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset cba45af in mainline


Ignore:
Timestamp:
2012-08-16T21:01:55Z (9 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
2bf781a
Parents:
e005f92
Message:

Rewrite logger (work in progress)

Major issues

  • no locking
  • no clean-up (at all)
Location:
uspace
Files:
1 added
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/io/log.c

    re005f92 rcba45af  
    6262#define MESSAGE_BUFFER_SIZE 4096
    6363
     64static sysarg_t toplog_id;
     65
    6466static int logger_register(async_sess_t *session, const char *prog_name)
    6567{
     
    6971        }
    7072
    71         aid_t reg_msg = async_send_0(exchange, LOGGER_REGISTER, NULL);
     73        ipc_call_t answer;
     74        aid_t reg_msg = async_send_0(exchange, LOGGER_WRITER_CREATE_TOPLEVEL_LOG, &answer);
    7275        int rc = async_data_write_start(exchange, prog_name, str_size(prog_name));
    7376        sysarg_t reg_msg_rc;
     
    8083        }
    8184
    82         return reg_msg_rc;
     85        if (reg_msg_rc != EOK)
     86                return reg_msg_rc;
     87
     88        toplog_id = IPC_GET_ARG1(answer);
     89
     90        return EOK;
    8391}
    8492
     
    9098        }
    9199
    92         aid_t reg_msg = async_send_2(exchange, LOGGER_MESSAGE,
    93             ctx, level, NULL);
     100        aid_t reg_msg = async_send_3(exchange, LOGGER_WRITER_MESSAGE,
     101            toplog_id, ctx, level, NULL);
    94102        int rc = async_data_write_start(exchange, message, str_size(message));
    95103        sysarg_t reg_msg_rc;
     
    183191
    184192        ipc_call_t answer;
    185         aid_t reg_msg = async_send_0(exchange, LOGGER_CREATE_CONTEXT, &answer);
     193        aid_t reg_msg = async_send_1(exchange, LOGGER_WRITER_CREATE_SUB_LOG, toplog_id, &answer);
    186194        int rc = async_data_write_start(exchange, name, str_size(name));
    187195        sysarg_t reg_msg_rc;
  • uspace/lib/c/generic/io/logctl.c

    re005f92 rcba45af  
    9090                return rc;
    9191
    92         aid_t reg_msg = async_send_1(exchange, LOGGER_CTL_SET_NAMESPACE_LEVEL,
     92        aid_t reg_msg = async_send_1(exchange, LOGGER_CTL_SET_TOP_LOG_LEVEL,
    9393            new_level, NULL);
    9494        rc = async_data_write_start(exchange, namespace, str_size(namespace));
     
    112112                return rc;
    113113
    114         aid_t reg_msg = async_send_1(exchange, LOGGER_CTL_SET_CONTEXT_LEVEL,
     114        aid_t reg_msg = async_send_1(exchange, LOGGER_CTL_SET_LOG_LEVEL,
    115115            new_level, NULL);
    116116        rc = async_data_write_start(exchange, namespace, str_size(namespace));
  • uspace/lib/c/include/ipc/logger.h

    re005f92 rcba45af  
    3737
    3838typedef enum {
    39         LOGGER_CTL_GET_DEFAULT_LEVEL = IPC_FIRST_USER_METHOD,
    40         LOGGER_CTL_SET_DEFAULT_LEVEL,
    41         LOGGER_CTL_SET_NAMESPACE_LEVEL,
    42         LOGGER_CTL_SET_CONTEXT_LEVEL
     39        LOGGER_CTL_SET_DEFAULT_LEVEL = IPC_FIRST_USER_METHOD,
     40        LOGGER_CTL_SET_TOP_LOG_LEVEL,
     41        LOGGER_CTL_SET_LOG_LEVEL
    4342} logger_control_request_t;
    4443
    4544typedef enum {
    46         LOGGER_REGISTER = IPC_FIRST_USER_METHOD,
    47         LOGGER_CREATE_CONTEXT,
    48         LOGGER_MESSAGE
    49 } logger_sink_request_t;
     45        /** Followed by STRING, returns ID to be used for CREATE_SUB_LOG */
     46        LOGGER_WRITER_CREATE_TOPLEVEL_LOG = IPC_FIRST_USER_METHOD,
     47        LOGGER_WRITER_CREATE_SUB_LOG,
     48        LOGGER_WRITER_MESSAGE
     49} logger_writer_request_t;
    5050
    5151typedef enum {
  • uspace/srv/logger/Makefile

    re005f92 rcba45af  
    3434        ctl.c \
    3535        level.c \
     36        logs.c \
    3637        main.c \
    37         namespace.c \
    3838        writer.c
    3939
  • uspace/srv/logger/ctl.c

    re005f92 rcba45af  
    4343#include "logger.h"
    4444
    45 static int handle_namespace_level_change(sysarg_t new_level)
     45static int handle_toplog_level_change(sysarg_t new_level)
    4646{
    47         void *namespace_name;
    48         int rc = async_data_write_accept(&namespace_name, true, 0, 0, 0, NULL);
     47        void *top_name;
     48        int rc = async_data_write_accept(&top_name, true, 0, 0, 0, NULL);
    4949        if (rc != EOK) {
    5050                return rc;
    5151        }
    5252
    53         logging_namespace_t *namespace = namespace_writer_attach((const char *) namespace_name);
    54         free(namespace_name);
    55         if (namespace == NULL)
     53        logger_toplevel_log_t *toplog = find_or_create_toplevel_log(top_name);
     54        free(top_name);
     55        if (toplog == NULL)
    5656                return ENOENT;
    5757
    58         rc = namespace_change_level(namespace, (log_level_t) new_level);
    59         namespace_writer_detach(namespace);
     58        toplog->logged_level = new_level;
    6059
    61         return rc;
     60        return EOK;
    6261}
    6362
    64 static int handle_context_level_change(sysarg_t new_level)
     63static int handle_log_level_change(sysarg_t new_level)
    6564{
    66         void *namespace_name;
    67         int rc = async_data_write_accept(&namespace_name, true, 0, 0, 0, NULL);
     65        void *top_name;
     66        int rc = async_data_write_accept(&top_name, true, 0, 0, 0, NULL);
    6867        if (rc != EOK) {
    6968                return rc;
    7069        }
    7170
    72         logging_namespace_t *namespace = namespace_writer_attach((const char *) namespace_name);
    73         free(namespace_name);
    74         if (namespace == NULL)
     71        logger_toplevel_log_t *toplog = find_or_create_toplevel_log(top_name);
     72        free(top_name);
     73        if (toplog == NULL)
    7574                return ENOENT;
    7675
    77         void *context_name;
    78         rc = async_data_write_accept(&context_name, true, 0, 0, 0, NULL);
    79         if (rc != EOK) {
    80                 namespace_writer_detach(namespace);
     76
     77        void *log_name;
     78        rc = async_data_write_accept(&log_name, true, 0, 0, 0, NULL);
     79        if (rc != EOK)
    8180                return rc;
     81
     82        rc = ENOENT;
     83        for (size_t i = 0; i < toplog->sublog_count; i++) {
     84                if (str_cmp(toplog->sublogs[i].name, (const char *) log_name) == 0) {
     85                        toplog->sublogs[i].logged_level = new_level;
     86                        rc = EOK;
     87                        break;
     88                }
    8289        }
    8390
    84         rc = namespace_change_context_level(namespace, context_name, new_level);
    85         free(context_name);
    86         namespace_writer_detach(namespace);
     91        free(log_name);
    8792
    8893        return rc;
     
    101106                        break;
    102107
    103                 int rc;
    104 
    105108                switch (IPC_GET_IMETHOD(call)) {
    106                 case LOGGER_CTL_GET_DEFAULT_LEVEL:
    107                         async_answer_1(callid, EOK, get_default_logging_level());
    108                         break;
    109                 case LOGGER_CTL_SET_DEFAULT_LEVEL:
    110                         rc = set_default_logging_level(IPC_GET_ARG1(call));
     109                case LOGGER_CTL_SET_DEFAULT_LEVEL: {
     110                        int rc = set_default_logging_level(IPC_GET_ARG1(call));
    111111                        async_answer_0(callid, rc);
    112112                        break;
    113                 case LOGGER_CTL_SET_NAMESPACE_LEVEL:
    114                         rc = handle_namespace_level_change(IPC_GET_ARG1(call));
     113                }
     114                case LOGGER_CTL_SET_TOP_LOG_LEVEL: {
     115                        int rc = handle_toplog_level_change(IPC_GET_ARG1(call));
    115116                        async_answer_0(callid, rc);
    116117                        break;
    117                 case LOGGER_CTL_SET_CONTEXT_LEVEL:
    118                         rc = handle_context_level_change(IPC_GET_ARG1(call));
     118                }
     119                case LOGGER_CTL_SET_LOG_LEVEL: {
     120                        int rc = handle_log_level_change(IPC_GET_ARG1(call));
    119121                        async_answer_0(callid, rc);
    120122                        break;
     123                }
    121124                default:
    122125                        async_answer_0(callid, EINVAL);
  • uspace/srv/logger/level.c

    re005f92 rcba45af  
    5252{
    5353        if (new_level >= LVL_LIMIT)
    54                 return EINVAL;
     54                return ERANGE;
    5555        fibril_mutex_lock(&default_logging_level_guard);
    5656        default_logging_level = new_level;
  • uspace/srv/logger/logger.h

    re005f92 rcba45af  
    4242#include <bool.h>
    4343#include <fibril_synch.h>
     44#include <stdio.h>
    4445
    4546#define NAME "logger"
    46 #define MAX_NAMESPACE_LENGTH 256
     47#define MAX_SUBLOGS 64
    4748#define LOG_LEVEL_USE_DEFAULT (LVL_LIMIT + 1)
    4849
    49 typedef struct logging_namespace logging_namespace_t;
     50typedef struct {
     51        const char *name;
     52        log_level_t logged_level;
     53} logger_sublog_t;
    5054
    51 logging_namespace_t *namespace_create(const char *);
    52 const char *namespace_get_name(logging_namespace_t *);
    53 void namespace_destroy(logging_namespace_t *);
    54 logging_namespace_t *namespace_writer_attach(const char *);
    55 void namespace_writer_detach(logging_namespace_t *);
     55typedef struct {
     56        const char *name;
     57        FILE *logfile;
     58        log_level_t logged_level;
     59        size_t sublog_count;
     60        logger_sublog_t sublogs[MAX_SUBLOGS];
    5661
    57 int namespace_change_level(logging_namespace_t *, log_level_t);
     62        link_t link;
     63} logger_toplevel_log_t;
    5864
    59 bool namespace_has_reader(logging_namespace_t *, sysarg_t, log_level_t);
    60 void namespace_add_message(logging_namespace_t *, const char *, sysarg_t, log_level_t);
    6165
    62 int namespace_create_context(logging_namespace_t *, const char *);
    63 int namespace_change_context_level(logging_namespace_t *, const char *, log_level_t);
     66logger_toplevel_log_t *find_or_create_toplevel_log(const char *);
     67logger_toplevel_log_t *find_toplevel_log(sysarg_t);
     68bool shall_log_message(logger_toplevel_log_t *, sysarg_t, log_level_t);
     69int add_sub_log(logger_toplevel_log_t *, const char *, sysarg_t *);
    6470
    6571log_level_t get_default_logging_level(void);
  • uspace/srv/logger/writer.c

    re005f92 rcba45af  
    4949
    5050
    51 static logging_namespace_t *find_namespace_and_attach_writer(void)
     51static logger_toplevel_log_t *handle_create_toplevel_log(void)
    5252{
    53         ipc_call_t call;
    54         ipc_callid_t callid = async_get_call(&call);
     53        void *name;
     54        int rc = async_data_write_accept(&name, true, 1, 0, 0, NULL);
     55        if (rc != EOK)
     56                return NULL;
    5557
    56         if (IPC_GET_IMETHOD(call) != LOGGER_REGISTER) {
    57                 async_answer_0(callid, EINVAL);
    58                 return NULL;
    59         }
    60 
    61         void *name;
    62         int rc = async_data_write_accept(&name, true, 1, MAX_NAMESPACE_LENGTH, 0, NULL);
    63         async_answer_0(callid, rc);
    64 
    65         if (rc != EOK) {
    66                 return NULL;
    67         }
    68 
    69         logging_namespace_t *result = namespace_writer_attach((const char *) name);
     58        logger_toplevel_log_t *log = find_or_create_toplevel_log(name);
    7059
    7160        free(name);
    7261
    73         return result;
     62        return log;
    7463}
    7564
    76 static int handle_receive_message(logging_namespace_t *namespace, sysarg_t context, int level)
     65static int handle_receive_message(sysarg_t toplevel_log_id, sysarg_t log_id, sysarg_t level)
    7766{
    78         bool skip_message = !namespace_has_reader(namespace, context, level);
    79         if (skip_message) {
    80                 /* Abort the actual message buffer transfer. */
    81                 ipc_callid_t callid;
    82                 size_t size;
    83                 int rc = ENAK;
    84                 if (!async_data_write_receive(&callid, &size))
    85                         rc = EINVAL;
     67        logger_toplevel_log_t *log = find_toplevel_log(toplevel_log_id);
     68        if (log == NULL)
     69                return ENOENT;
    8670
    87                 async_answer_0(callid, rc);
     71        if (log_id > log->sublog_count)
     72                return ENOENT;
     73
     74        void *message;
     75        int rc = async_data_write_accept(&message, true, 1, 0, 0, NULL);
     76        if (rc != EOK)
    8877                return rc;
     78
     79        if (!shall_log_message(log, log_id, level)) {
     80                free(message);
     81                return EOK;
    8982        }
    9083
    91         void *message;
    92         int rc = async_data_write_accept(&message, true, 0, 0, 0, NULL);
    93         if (rc != EOK) {
    94                 return rc;
    95         }
    96 
    97         namespace_add_message(namespace, message, context, level);
     84        printf("[%s/%s] %s: %s\n",
     85            log->name, log->sublogs[log_id].name,
     86            log_level_str(level),
     87            (const char *) message);
    9888
    9989        free(message);
     
    10292}
    10393
    104 static int handle_create_context(logging_namespace_t *namespace, sysarg_t *idx)
     94static int handle_create_sub_log(sysarg_t toplevel_log_id, sysarg_t *log_id)
    10595{
     96        logger_toplevel_log_t *log = find_toplevel_log(toplevel_log_id);
     97        if (log == NULL)
     98                return ENOENT;
     99
    106100        void *name;
    107101        int rc = async_data_write_accept(&name, true, 0, 0, 0, NULL);
    108         if (rc != EOK) {
     102        if (rc != EOK)
    109103                return rc;
    110         }
    111104
    112         rc = namespace_create_context(namespace, name);
     105        rc = add_sub_log(log, name, log_id);
    113106
    114107        free(name);
    115108
    116         if (rc < 0)
    117                 return rc;
    118 
    119         *idx = (sysarg_t) rc;
    120         return EOK;
     109        return rc;
    121110}
    122111
    123112void logger_connection_handler_writer(ipc_callid_t callid)
    124113{
    125         /* First call has to be the registration. */
     114        /* Acknowledge the connection. */
    126115        async_answer_0(callid, EOK);
    127         logging_namespace_t *namespace = find_namespace_and_attach_writer();
    128         if (namespace == NULL) {
    129                 fprintf(stderr, NAME ": failed to register namespace.\n");
    130                 return;
    131         }
    132116
    133         printf(NAME "/writer: new client %s.\n", namespace_get_name(namespace));
     117        printf(NAME "/writer: new client.\n");
    134118
    135119        while (true) {
     
    140124                        break;
    141125
    142                 int rc;
    143                 sysarg_t arg = 0;
    144 
    145126                switch (IPC_GET_IMETHOD(call)) {
    146                 case LOGGER_CREATE_CONTEXT:
    147                         rc = handle_create_context(namespace, &arg);
    148                         async_answer_1(callid, rc, arg);
     127                case LOGGER_WRITER_CREATE_TOPLEVEL_LOG: {
     128                        logger_toplevel_log_t *log = handle_create_toplevel_log();
     129                        if (log == NULL) {
     130                                async_answer_0(callid, ENOMEM);
     131                                break;
     132                        }
     133                        async_answer_1(callid, EOK, (sysarg_t) log);
    149134                        break;
    150                 case LOGGER_MESSAGE:
    151                         rc = handle_receive_message(namespace, IPC_GET_ARG1(call), IPC_GET_ARG2(call));
     135                }
     136                case LOGGER_WRITER_MESSAGE: {
     137                        int rc = handle_receive_message(IPC_GET_ARG1(call),
     138                            IPC_GET_ARG2(call), IPC_GET_ARG3(call));
    152139                        async_answer_0(callid, rc);
    153140                        break;
     141                }
     142                case LOGGER_WRITER_CREATE_SUB_LOG: {
     143                        sysarg_t log_id;
     144                        int rc = handle_create_sub_log(IPC_GET_ARG1(call), &log_id);
     145                        async_answer_1(callid, rc, log_id);
     146                        break;
     147                }
    154148                default:
    155149                        async_answer_0(callid, EINVAL);
     
    158152        }
    159153
    160         printf(NAME "/sink: client %s terminated.\n", namespace_get_name(namespace));
    161         namespace_writer_detach(namespace);
     154        // FIXME: destroy created logs
    162155}
    163156
Note: See TracChangeset for help on using the changeset viewer.