Changeset f039dba in mainline for uspace/srv/logger


Ignore:
Timestamp:
2012-08-17T09:57:27Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b1912b0c
Parents:
f72ae3b
Message:

Logger also works with hierarchy

Location:
uspace/srv/logger
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/logger/ctl.c

    rf72ae3b rf039dba  
    4343#include "logger.h"
    4444
    45 static int handle_toplog_level_change(sysarg_t new_level)
     45static int handle_log_level_change(sysarg_t new_level)
    4646{
    47         void *top_name;
    48         int rc = async_data_write_accept(&top_name, true, 0, 0, 0, NULL);
     47        void *full_name;
     48        int rc = async_data_write_accept(&full_name, true, 0, 0, 0, NULL);
    4949        if (rc != EOK) {
    5050                return rc;
    5151        }
    5252
    53         logger_toplevel_log_t *toplog = find_or_create_toplevel_log(top_name);
    54         free(top_name);
    55         if (toplog == NULL)
     53        logger_log_t *log = find_log_by_name(full_name);
     54        free(full_name);
     55        if (log == NULL)
    5656                return ENOENT;
    5757
    58         toplog->logged_level = new_level;
     58        log->logged_level = new_level;
    5959
    6060        return EOK;
    61 }
    62 
    63 static int handle_log_level_change(sysarg_t new_level)
    64 {
    65         void *top_name;
    66         int rc = async_data_write_accept(&top_name, true, 0, 0, 0, NULL);
    67         if (rc != EOK) {
    68                 return rc;
    69         }
    70 
    71         logger_toplevel_log_t *toplog = find_or_create_toplevel_log(top_name);
    72         free(top_name);
    73         if (toplog == NULL)
    74                 return ENOENT;
    75 
    76 
    77         void *log_name;
    78         rc = async_data_write_accept(&log_name, true, 0, 0, 0, NULL);
    79         if (rc != EOK)
    80                 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                 }
    89         }
    90 
    91         free(log_name);
    92 
    93         return rc;
    9461}
    9562
    … …  
    10976                case LOGGER_CTL_SET_DEFAULT_LEVEL: {
    11077                        int rc = set_default_logging_level(IPC_GET_ARG1(call));
    111                         async_answer_0(callid, rc);
    112                         break;
    113                 }
    114                 case LOGGER_CTL_SET_TOP_LOG_LEVEL: {
    115                         int rc = handle_toplog_level_change(IPC_GET_ARG1(call));
    11678                        async_answer_0(callid, rc);
    11779                        break;

  • uspace/srv/logger/initlvl.c

    rf72ae3b rf039dba  
    6161                return;
    6262
    63         logger_toplevel_log_t *log = find_or_create_toplevel_log(key);
     63        logger_log_t *log = find_or_create_log(key, 0);
    6464        if (log == NULL)
    6565                return;

  • uspace/srv/logger/logger.h

    rf72ae3b rf039dba  
    4848#define LOG_LEVEL_USE_DEFAULT (LVL_LIMIT + 1)
    4949
    50 typedef struct {
    51         const char *name;
    52         log_level_t logged_level;
    53 } logger_sublog_t;
     50typedef struct logger_log logger_log_t;
    5451
    5552typedef struct {
    56         const char *name;
    5753        FILE *logfile;
     54} logger_dest_t;
     55
     56struct logger_log {
     57        link_t link;
     58
     59        char *name;
     60        char *full_name;
     61        logger_log_t *parent;
    5862        log_level_t logged_level;
    59         size_t sublog_count;
    60         logger_sublog_t sublogs[MAX_SUBLOGS];
     63        logger_dest_t *dest;
     64};
    6165
    62         link_t link;
    63 } logger_toplevel_log_t;
    64 
    65 
    66 logger_toplevel_log_t *find_or_create_toplevel_log(const char *);
    67 logger_toplevel_log_t *find_toplevel_log(sysarg_t);
    68 bool shall_log_message(logger_toplevel_log_t *, sysarg_t, log_level_t);
    69 int add_sub_log(logger_toplevel_log_t *, const char *, sysarg_t *);
     66logger_log_t *find_log_by_name(const char *name);
     67logger_log_t *find_or_create_log(const char *name, sysarg_t parent);
     68logger_log_t *find_log_by_id(sysarg_t);
     69bool shall_log_message(logger_log_t *, log_level_t);
    7070
    7171log_level_t get_default_logging_level(void);

  • uspace/srv/logger/logs.c

    rf72ae3b rf039dba  
    3737#include "logger.h"
    3838
    39 static FIBRIL_MUTEX_INITIALIZE(toplog_list_guard);
    40 static LIST_INITIALIZE(toplog_list);
    4139
    42 static logger_toplevel_log_t *find_log_by_name_no_lock(const char *name)
     40static FIBRIL_MUTEX_INITIALIZE(log_list_guard);
     41static LIST_INITIALIZE(log_list);
     42
     43
     44static logger_log_t *find_log_by_name_and_parent_no_lock(const char *name, logger_log_t *parent)
    4345{
    44         list_foreach(toplog_list, it) {
    45                 logger_toplevel_log_t *log = list_get_instance(it, logger_toplevel_log_t, link);
    46                 if (str_cmp(log->name, name) == 0) {
    47                         return log;
    48                 }
    49         }
    50 
    51         return NULL;
    52 }
    53 
    54 logger_toplevel_log_t *find_or_create_toplevel_log(const char *name)
    55 {
    56         logger_toplevel_log_t *result = NULL;
    57 
    58         fibril_mutex_lock(&toplog_list_guard);
    59 
    60         result = find_log_by_name_no_lock(name);
    61         if (result != NULL)
    62                 goto leave;
    63 
    64         result = malloc(sizeof(logger_toplevel_log_t));
    65         if (result == NULL)
    66                 goto leave;
    67 
    68         char *logfilename;
    69         asprintf(&logfilename, "/log/%s", name);
    70         result->logfile = fopen(logfilename, "a");
    71         result->logged_level = LOG_LEVEL_USE_DEFAULT;
    72         result->name = str_dup(name);
    73         result->sublog_count = 1;
    74         result->sublogs[0].name = "";
    75         result->sublogs[0].logged_level = LOG_LEVEL_USE_DEFAULT;
    76 
    77         link_initialize(&result->link);
    78 
    79         list_append(&result->link, &toplog_list);
    80 
    81 leave:
    82         fibril_mutex_unlock(&toplog_list_guard);
    83 
    84         return result;
    85 }
    86 
    87 logger_toplevel_log_t *find_toplevel_log(sysarg_t id)
    88 {
    89         list_foreach(toplog_list, it) {
    90                 logger_toplevel_log_t *log = list_get_instance(it, logger_toplevel_log_t, link);
    91                 if ((sysarg_t) log == id)
     46        list_foreach(log_list, it) {
     47                logger_log_t *log = list_get_instance(it, logger_log_t, link);
     48                if ((parent == log->parent) && (str_cmp(log->name, name) == 0))
    9249                        return log;
    9350        }
    … …  
    9653}
    9754
    98 bool shall_log_message(logger_toplevel_log_t *toplog, sysarg_t log, log_level_t level)
     55static logger_dest_t *create_dest(const char *name)
    9956{
    100         if (log >= toplog->sublog_count)
    101                 return false;
     57        logger_dest_t *result = malloc(sizeof(logger_dest_t));
     58        char *logfilename;
     59        asprintf(&logfilename, "/log/%s", name);
     60        result->logfile = fopen(logfilename, "a");
     61        return result;
     62}
    10263
    103         log_level_t logged_level = toplog->sublogs[log].logged_level;
    104         if (logged_level == LOG_LEVEL_USE_DEFAULT) {
    105                 logged_level = toplog->logged_level;
    106                 if (logged_level == LOG_LEVEL_USE_DEFAULT)
    107                         logged_level = get_default_logging_level();
    108         }
     64logger_log_t *find_or_create_log(const char *name, sysarg_t parent_id)
     65{
     66        logger_log_t *result = NULL;
     67        logger_log_t *parent = (logger_log_t *) parent_id;
     68
     69        fibril_mutex_lock(&log_list_guard);
     70
     71        result = find_log_by_name_and_parent_no_lock(name, parent);
     72        if (result != NULL)
     73                goto leave;
     74
     75        result = malloc(sizeof(logger_log_t));
     76        if (result == NULL)
     77                goto leave;
    10978
    11079
    111         return level <= logged_level;
     80        result->logged_level = LOG_LEVEL_USE_DEFAULT;
     81        result->name = str_dup(name);
     82        if (parent == NULL) {
     83                result->full_name = str_dup(name);
     84                result->dest = create_dest(name);
     85        } else {
     86                asprintf(&result->full_name, "%s/%s", parent->full_name, name);
     87                result->dest = parent->dest;
     88        }
     89        result->parent = parent;
     90
     91        link_initialize(&result->link);
     92
     93        list_append(&result->link, &log_list);
     94
     95leave:
     96        fibril_mutex_unlock(&log_list_guard);
     97
     98        return result;
    11299}
    113100
    114 int add_sub_log(logger_toplevel_log_t *toplog, const char *name, sysarg_t *id)
     101logger_log_t *find_log_by_name(const char *name)
    115102{
    116         if (toplog->sublog_count >= MAX_SUBLOGS)
    117                 return ELIMIT;
     103        logger_log_t *result = NULL;
    118104
    119         logger_sublog_t *sublog =  &toplog->sublogs[toplog->sublog_count];
    120         sublog->name = str_dup(name);
    121         sublog->logged_level = toplog->logged_level;
     105        fibril_mutex_lock(&log_list_guard);
     106        list_foreach(log_list, it) {
     107                logger_log_t *log = list_get_instance(it, logger_log_t, link);
     108                if (str_cmp(log->full_name, name) == 0) {
     109                        result = log;
     110                        break;
     111                }
     112        }
     113        fibril_mutex_unlock(&log_list_guard);
    122114
    123         *id = toplog->sublog_count;
    124 
    125         toplog->sublog_count++;
    126 
    127         return EOK;
     115        return result;
    128116}
    129117
     118logger_log_t *find_log_by_id(sysarg_t id)
     119{
     120        logger_log_t *result = NULL;
     121
     122        fibril_mutex_lock(&log_list_guard);
     123        list_foreach(log_list, it) {
     124                logger_log_t *log = list_get_instance(it, logger_log_t, link);
     125                if ((sysarg_t) log == id) {
     126                        result = log;
     127                        break;
     128                }
     129        }
     130        fibril_mutex_unlock(&log_list_guard);
     131
     132        return result;
     133}
     134
     135static log_level_t get_actual_log_level(logger_log_t *log)
     136{
     137        /* Find recursively proper log level. */
     138        if (log->logged_level == LOG_LEVEL_USE_DEFAULT) {
     139                if (log->parent == NULL)
     140                        return get_default_logging_level();
     141                else
     142                        return get_actual_log_level(log->parent);
     143        }
     144        return log->logged_level;
     145}
     146
     147bool shall_log_message(logger_log_t *log, log_level_t level)
     148{
     149        return level <= get_actual_log_level(log);
     150}
    130151
    131152/**

  • uspace/srv/logger/writer.c

    rf72ae3b rf039dba  
    4949
    5050
    51 static logger_toplevel_log_t *handle_create_toplevel_log(void)
     51static logger_log_t *handle_create_log(sysarg_t parent)
    5252{
    5353        void *name;
    … …  
    5656                return NULL;
    5757
    58         logger_toplevel_log_t *log = find_or_create_toplevel_log(name);
     58        logger_log_t *log = find_or_create_log(name, parent);
    5959
    6060        free(name);
    … …  
    6363}
    6464
    65 static int handle_receive_message(sysarg_t toplevel_log_id, sysarg_t log_id, sysarg_t level)
     65static int handle_receive_message(sysarg_t log_id, sysarg_t level)
    6666{
    67         logger_toplevel_log_t *log = find_toplevel_log(toplevel_log_id);
     67        logger_log_t *log = find_log_by_id(log_id);
    6868        if (log == NULL)
    69                 return ENOENT;
    70 
    71         if (log_id > log->sublog_count)
    7269                return ENOENT;
    7370
    … …  
    7774                return rc;
    7875
    79         if (!shall_log_message(log, log_id, level)) {
     76        if (!shall_log_message(log, level)) {
    8077                free(message);
    8178                return EOK;
    8279        }
    8380
    84         printf("[%s/%s] %s: %s\n",
    85             log->name, log->sublogs[log_id].name,
    86             log_level_str(level),
     81        printf("[%s] %s: %s\n",
     82            log->full_name, log_level_str(level),
    8783            (const char *) message);
    8884
    … …  
    9086
    9187        return EOK;
    92 }
    93 
    94 static int handle_create_sub_log(sysarg_t toplevel_log_id, sysarg_t *log_id)
    95 {
    96         logger_toplevel_log_t *log = find_toplevel_log(toplevel_log_id);
    97         if (log == NULL)
    98                 return ENOENT;
    99 
    100         void *name;
    101         int rc = async_data_write_accept(&name, true, 0, 0, 0, NULL);
    102         if (rc != EOK)
    103                 return rc;
    104 
    105         rc = add_sub_log(log, name, log_id);
    106 
    107         free(name);
    108 
    109         return rc;
    11088}
    11189
    … …  
    125103
    126104                switch (IPC_GET_IMETHOD(call)) {
    127                 case LOGGER_WRITER_CREATE_TOPLEVEL_LOG: {
    128                         logger_toplevel_log_t *log = handle_create_toplevel_log();
     105                case LOGGER_WRITER_CREATE_LOG: {
     106                        logger_log_t *log = handle_create_log(IPC_GET_ARG1(call));
    129107                        if (log == NULL) {
    130108                                async_answer_0(callid, ENOMEM);
    … …  
    136114                case LOGGER_WRITER_MESSAGE: {
    137115                        int rc = handle_receive_message(IPC_GET_ARG1(call),
    138                             IPC_GET_ARG2(call), IPC_GET_ARG3(call));
     116                            IPC_GET_ARG2(call));
    139117                        async_answer_0(callid, rc);
    140                         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);
    146118                        break;
    147119                }
Note: See TracChangeset for help on using the changeset viewer.