openbcm

Git mirror of https://github.com/Broadcom-Network-Switching-Software/OpenBCM
git clone git://git.finwo.net/mirror/broadcom/openbcm
Log | Files | Refs | README

bsl.c (9653B)

      1 /*
      2  * 
      3  * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
      4  * 
      5  * Copyright 2007-2019 Broadcom Inc. All rights reserved.
      6  *
      7  * Broadcom System Log (BSL)
      8  *
      9  * BSL functions for INTERNAL (SDK) usage.
     10  */
     11 
     12 #include <sal/core/libc.h>
     13 #include <shared/bsl.h>
     14 
     15 #define BSL_BUFFER_SIZE 4096
     16 
     17 /* 
     18   * convenience functions/macros to allow compiling out severity levels;
     19   * preferred to directly calling sal_log.  See sal_log for parameter
     20   * descriptions 
     21   */
     22 static bsl_config_t bsl_config;
     23 
     24 int
     25 bsl_init(bsl_config_t *config)
     26 {
     27     bsl_config = *config;
     28     return 0;
     29 }
     30 
     31 void
     32 bsl_config_t_init(bsl_config_t *config)
     33 {
     34     sal_memset(config, 0, sizeof(*config));
     35 }
     36 
     37 /* "Fast" checker function for a single 'chk' */
     38 int
     39 bsl_fast_check(uint32 chk)
     40 {
     41     if (bsl_config.check_hook != NULL) {
     42         return bsl_config.check_hook(chk);
     43     }
     44     return 0;
     45 }
     46 
     47 /*
     48  * "Fast" checker function for a two 'chk's
     49  * Return '0' if both 'chk's indicate 'disabled'
     50  *   or if no hook was assigned.
     51  * Otherwise (one of the 'chk's indicates 'enabled'), return '1'
     52  */
     53 int
     54 bsl_fast_check_two(uint32 chk1,uint32 chk2)
     55 {
     56     if (bsl_config.check_hook != NULL)
     57     {
     58         int rv1, rv2;
     59         rv1 = bsl_config.check_hook(chk1);
     60         rv2 = bsl_config.check_hook(chk2);
     61         if ((!rv1) && (!rv2))
     62         {
     63             return (0);
     64         }
     65         else
     66         {
     67             return (1);
     68         }
     69     }
     70     return 0;
     71 }
     72 
     73 
     74 int
     75 bsl_check(bsl_layer_t layer, int source, bsl_severity_t severity, int unit) 
     76 {
     77     uint32 chk;
     78 
     79     chk = BSL_LAYER_ENC(layer);
     80     chk |= BSL_SOURCE_ENC(source);
     81     chk |= BSL_SEVERITY_ENC(severity);
     82 
     83     return bsl_fast_check(chk);
     84 }
     85 
     86 /* Output function */
     87 int
     88 bsl_vlog(bsl_meta_t *meta, const char *format, va_list args)
     89 {
     90     if (bsl_config.out_hook != NULL) {
     91         return bsl_config.out_hook(meta, format, args);
     92     }
     93     return 0;
     94 }
     95 
     96 /* BSL vprintf which can extract meta data */
     97 int
     98 bsl_log(bsl_meta_t *meta, const char *format, ...)
     99 {
    100     int rc; 
    101     va_list vargs;
    102 
    103     va_start(vargs, format);
    104     rc = bsl_vlog(meta, format, vargs);
    105     va_end(vargs);
    106 
    107     return rc; 
    108 }
    109 
    110 /* BSL vprintf which can extract meta data */
    111 int
    112 bsl_vprintf(const char *format, va_list args)
    113 {
    114     const char *fmt = format;
    115     bsl_meta_t meta_data, *meta = &meta_data;
    116 
    117     bsl_meta_t_init(meta);
    118 
    119     if (*fmt == '<') {
    120         fmt++;
    121         while (1) {
    122             if (sal_strncmp(fmt, "u=%d", 4) == 0) {
    123                 meta->unit = va_arg(args, int);
    124                 fmt += 4;
    125             } else if (sal_strncmp(fmt, "p=%d", 4) == 0) {
    126                 meta->port = va_arg(args, int);
    127                 fmt += 4;
    128             } else if (sal_strncmp(fmt, "x=%d", 4) == 0) {
    129                 meta->xtra = va_arg(args, int);
    130                 fmt += 4;
    131             } else if (sal_strncmp(fmt, "c=%u", 4) == 0) {
    132                 unsigned int chk = va_arg(args, unsigned int);
    133                 meta->layer = BSL_LAYER_GET(chk);
    134                 meta->source = BSL_SOURCE_GET(chk);
    135                 meta->severity = BSL_SEVERITY_GET(chk);
    136                 fmt += 4;
    137             } else if (sal_strncmp(fmt, "f=%s", 4) == 0) {
    138                 meta->file = va_arg(args, char *);
    139                 fmt += 4;
    140             } else if (sal_strncmp(fmt, "l=%d", 4) == 0) {
    141                 meta->line = va_arg(args, int);
    142                 fmt += 4;
    143             } else if (sal_strncmp(fmt, "F=%s", 4) == 0) {
    144                 meta->func = va_arg(args, char *);
    145                 fmt += 4;
    146             } else if (sal_strncmp(fmt, "o=%u", 4) == 0) {
    147                 meta->options = va_arg(args, unsigned int);
    148                 fmt += 4;
    149             } else {
    150                 break;
    151             }
    152         }
    153         if (*fmt == '>') {
    154             fmt++;
    155         }
    156     }
    157 
    158     /* Default to shell output */
    159     if (meta->layer == bslLayerCount) {
    160         meta->layer = bslLayerAppl;
    161         meta->source = bslSourceShell;
    162         meta->severity = bslSeverityNormal;
    163     }
    164 
    165     /* Call output hook with whatever is left over */
    166     return bsl_vlog(meta, fmt, args);
    167 }
    168 
    169 /* BSL printf which maps ... to vargs */
    170 int
    171 bsl_printf(const char *format, ...)
    172 {
    173     int rc; 
    174     va_list vargs;
    175 
    176     va_start(vargs, format);
    177     rc = bsl_vprintf(format, vargs);
    178     va_end(vargs);
    179 
    180     return rc; 
    181 }
    182 
    183 int 
    184 _bsl_error(char *file, unsigned int line, const char *func,
    185           bsl_layer_t layer, int source,
    186           int unit, const char *msg, ...)
    187 {
    188     int rc;
    189     va_list vargs;
    190     bsl_meta_t meta_data, *meta ;
    191 
    192     if (!bsl_check(layer, source, bslSeverityError, -1)) {
    193         return 0;
    194     }
    195 
    196     meta = &meta_data;
    197     bsl_meta_t_init(meta);
    198     meta->func = func;
    199     meta->file = file;
    200     meta->line = line;
    201     meta->layer = layer;
    202     meta->source = source;
    203     meta->severity = bslSeverityError;
    204     meta->unit = unit;
    205 
    206     va_start(vargs, msg);
    207     rc = bsl_vlog(meta, msg, vargs);
    208     va_end(vargs);
    209 
    210     return rc;
    211 }
    212 
    213 int 
    214 _bsl_warn(char *file, unsigned int line, const char *func,
    215           bsl_layer_t layer, int source,
    216           int unit, const char *msg, ...)
    217 {
    218     int rc;
    219     va_list vargs;
    220     bsl_meta_t meta_data, *meta ;
    221 
    222     if (!bsl_check(layer, source, bslSeverityWarn, -1)) {
    223         return 0;
    224     }
    225 
    226     meta = &meta_data;
    227     bsl_meta_t_init(meta);
    228     meta->func = func;
    229     meta->file = file;
    230     meta->line = line;
    231     meta->layer = layer;
    232     meta->source = source;
    233     meta->severity = bslSeverityWarn;
    234     meta->unit = unit;
    235 
    236     va_start(vargs, msg);
    237     rc = bsl_vlog(meta, msg, vargs);
    238     va_end(vargs);
    239 
    240     return rc;
    241 }
    242 
    243 int 
    244 _bsl_verbose(char *file, unsigned int line, const char *func,
    245           bsl_layer_t layer, int source,
    246           int unit, const char *msg, ...)
    247 {
    248     int rc;
    249     va_list vargs;
    250     bsl_meta_t meta_data, *meta ;
    251 
    252     if (!bsl_check(layer, source, bslSeverityVerbose, -1)) {
    253         return 0;
    254     }
    255 
    256     meta = &meta_data;
    257     bsl_meta_t_init(meta);
    258     meta->func = func;
    259     meta->file = file;
    260     meta->line = line;
    261     meta->layer = layer;
    262     meta->source = source;
    263     meta->severity = bslSeverityVerbose;
    264     meta->unit = unit;
    265 
    266     va_start(vargs, msg);
    267     rc = bsl_vlog(meta, msg, vargs);
    268     va_end(vargs);
    269 
    270     return rc;
    271 }
    272 
    273 int 
    274 _bsl_vverbose(char *file, unsigned int line, const char *func,
    275           bsl_layer_t layer, int source,
    276           int unit, const char *msg, ...)
    277 {
    278     int rc;
    279     va_list vargs;
    280     bsl_meta_t meta_data, *meta ;
    281 
    282     if (!bsl_check(layer, source, bslSeverityDebug, -1)) {
    283         return 0;
    284     }
    285 
    286     meta = &meta_data;
    287     bsl_meta_t_init(meta);
    288     meta->func = func;
    289     meta->file = file;
    290     meta->line = line;
    291     meta->layer = layer;
    292     meta->source = source;
    293     meta->severity = bslSeverityDebug;
    294     meta->unit = unit;
    295 
    296     va_start(vargs, msg);
    297     rc = bsl_vlog(meta, msg, vargs);
    298     va_end(vargs);
    299 
    300     return rc;
    301 }
    302 
    303 void
    304 bsl_meta_t_init(bsl_meta_t *meta)
    305 {
    306     sal_memset(meta, 0, sizeof(*meta));
    307     meta->options = BSL_META_OPT_START | BSL_META_OPT_END;
    308     meta->layer = bslLayerCount;
    309     meta->source = bslSourceCount;
    310     meta->severity = bslSeverityCount;
    311     meta->unit = -1;
    312     meta->port = -1;
    313     meta->xtra = -1;
    314 }
    315 
    316 /* 
    317  * bsl_start
    318  * Parameters: as per bsl_vlog
    319  */
    320 int
    321 bsl_log_start(char *file, unsigned int line, const char *func, 
    322               bsl_layer_t layer, int source, bsl_severity_t severity,
    323               int unit, const char *msg, ...)
    324 {
    325     int rc;
    326     va_list vargs;
    327     bsl_meta_t meta_data, *meta ;
    328 
    329     if (!bsl_check(layer, source, severity, -1)) {
    330         return 0;
    331     }
    332 
    333     meta = &meta_data;
    334     bsl_meta_t_init(meta);
    335     meta->options = BSL_META_OPT_START;
    336     meta->func = func;
    337     meta->file = file;
    338     meta->line = line;
    339     meta->layer = layer;
    340     meta->source = source;
    341     meta->severity = severity;
    342     meta->unit = unit;
    343 
    344     va_start(vargs, msg);
    345     rc = bsl_vlog(meta, msg, vargs);
    346     va_end(vargs);
    347 
    348     return rc;
    349 }
    350 
    351 /* 
    352  * bsl_end
    353  * Incrementally adds additional output to a message previously begun with bsl_start
    354  * and finishes that message
    355  * Parameters: as per bsl_vlog 
    356  */
    357 int
    358 bsl_log_end(char *file, unsigned int line, const char *func, 
    359             bsl_layer_t layer, int source, bsl_severity_t severity,
    360             int sinks, int unit, 
    361             const char *msg, ...)
    362 {
    363     int rc;
    364     va_list vargs;
    365     bsl_meta_t meta_data, *meta ;
    366 
    367     if (!bsl_check(layer, source, severity, -1)) {
    368         return 0;
    369     }
    370 
    371     meta = &meta_data;
    372     bsl_meta_t_init(meta);
    373     meta->options = BSL_META_OPT_END;
    374     meta->func = func;
    375     meta->file = file;
    376     meta->line = line;
    377     meta->layer = layer;
    378     meta->source = source;
    379     meta->severity = severity;
    380     meta->unit = unit;
    381 
    382     va_start(vargs, msg);
    383     rc = bsl_vlog(meta, msg, vargs);
    384     va_end(vargs);
    385 
    386     return rc;
    387 }
    388 /* 
    389  * bsl_add
    390  * Incrementally adds additional output to a message previously begun with bsl_start 
    391  * Parameters: as per bsl_vlog 
    392  */
    393 int
    394 bsl_log_add(char *file, unsigned int line, const char *func, 
    395             bsl_layer_t layer, int source, bsl_severity_t severity,
    396             int sinks, int unit, 
    397             const char *msg, ...)
    398 {
    399     int rc;
    400     va_list vargs;
    401     bsl_meta_t meta_data, *meta ;
    402 
    403     if (!bsl_check(layer, source, severity, -1)) {
    404         return 0;
    405     }
    406 
    407     meta = &meta_data;
    408     bsl_meta_t_init(meta);
    409     meta->options = 0;
    410     meta->func = func;
    411     meta->file = file;
    412     meta->line = line;
    413     meta->layer = layer;
    414     meta->source = source;
    415     meta->severity = severity;
    416     meta->unit = unit;
    417 
    418     va_start(vargs, msg);
    419     rc = bsl_vlog(meta, msg, vargs);
    420     va_end(vargs);
    421 
    422     return rc;
    423 }