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

bslenable.c (3699B)

      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 Enables
      8  */
      9 
     10 #include <shared/bslnames.h>
     11 #include <appl/diag/bslenable.h>
     12 #include <sal/core/thread.h>
     13 
     14 /* Table for tracking which layers/sources/severities to enable */
     15 static bsl_severity_t bslenable_severity[bslLayerCount][bslSourceCount];
     16 
     17 /* Which sources are valid in which layers (fixed) */
     18 BSL_SOURCES_VALID_DEF(bsl_source_t);
     19 static bsl_source_t *sources_valid[] = BSL_SOURCES_VALID_INIT;
     20 
     21 /* List of threads for which a specific debug level is enabled.*/
     22 typedef struct {
     23     int   thread[MAX_BSLENABLE_THREAD_COUNT];
     24 } bslenable_thread_t;
     25 
     26 /* Table of tracking which layers/sources/thread-list to enable */
     27 static bslenable_thread_t bslenable_thread[bslLayerCount][bslSourceCount];
     28 
     29 void
     30 bslenable_thread_set(bsl_layer_t layer, bsl_source_t source, int tidx,
     31                      int thread)
     32 {
     33     bslenable_thread_t *thread_list;
     34 
     35     if (layer < 0 || layer >= bslLayerCount) {
     36         return;
     37     }
     38     if (tidx < 0 || tidx >= MAX_BSLENABLE_THREAD_COUNT) {
     39         return;
     40     }
     41     thread_list = &bslenable_thread[layer][source];
     42 
     43     thread_list->thread[tidx] = thread;
     44 }
     45 
     46 int
     47 bslenable_thread_get(bsl_layer_t layer, bsl_source_t source, int tidx)
     48 {
     49     bslenable_thread_t *thread_list;
     50 
     51     thread_list = &bslenable_thread[layer][source];
     52     if (layer < bslLayerCount && source < bslSourceCount &&
     53         tidx < MAX_BSLENABLE_THREAD_COUNT) {
     54         return thread_list->thread[tidx];
     55     }
     56 
     57     return 0;
     58 }
     59 
     60 void
     61 bslenable_thread_reset(bsl_layer_t layer, bsl_source_t source, int tidx)
     62 {
     63     bslenable_thread_set(layer, source, tidx, 0);
     64 }
     65 
     66 void
     67 bslenable_thread_reset_all(void)
     68 {
     69     int layer, source, tidx;
     70 
     71     for (layer = 0; layer < bslLayerCount; layer++) {
     72         for (source = 0; source < bslSourceCount; source++) {
     73             for (tidx = 0; tidx < MAX_BSLENABLE_THREAD_COUNT; tidx ++) {
     74                 bslenable_thread_reset(layer, source, tidx);
     75             }
     76         }
     77     }
     78 }
     79 
     80 int
     81 bslenable_source_valid(bsl_layer_t layer, bsl_source_t source)
     82 {
     83     bsl_source_t *src;
     84     int idx;
     85 
     86     if (layer < 0 || layer >= bslLayerCount) {
     87         return 0;
     88     }
     89     if (source < 0 || source >= bslSourceCount) {
     90         return 0;
     91     }
     92     src = sources_valid[layer];
     93     for (idx = 0; src[idx] != bslSourceCount && idx < bslSourceCount; idx++) {
     94         if (source == src[idx]) {
     95             return 1;
     96         }
     97     }
     98     return 0;
     99 }
    100 
    101 void
    102 bslenable_set(bsl_layer_t layer, bsl_source_t source, bsl_severity_t severity)
    103 {
    104     if (layer < 0 || layer >= bslLayerCount) {
    105         return;
    106     }
    107     bslenable_severity[layer][source] = severity;
    108 }
    109 
    110 bsl_severity_t
    111 bslenable_get(bsl_layer_t layer, bsl_source_t source)
    112 {
    113     if (layer < bslLayerCount && source < bslSourceCount) {
    114         return bslenable_severity[layer][source];
    115     }
    116         
    117     return 0;
    118 }
    119 
    120 void
    121 bslenable_reset(bsl_layer_t layer, bsl_source_t source)
    122 {
    123     bsl_severity_t severity = bslSeverityWarn;
    124 
    125     if (source == bslSourceShell ||
    126         source == bslSourceEcho ||
    127         (layer == bslLayerTks && source == bslSourceCommon)) {
    128         severity = bslSeverityInfo;
    129     }
    130         
    131     bslenable_set(layer, source, severity);
    132 }
    133 
    134 void
    135 bslenable_reset_all(void)
    136 {
    137     int layer, source;
    138 
    139     for (layer = 0; layer < bslLayerCount; layer++) {
    140         for (source = 0; source < bslSourceCount; source++) {
    141             bslenable_reset(layer, source);
    142         }
    143     }
    144 }
    145 
    146 int
    147 bslenable_init(void)
    148 {
    149     bslenable_reset_all();
    150     bslenable_thread_reset_all();
    151     return 0;
    152 }