lib/librte_eal/common/eal_common_log.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdint.h>
   7 #include <stdarg.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <regex.h>
  12
  13 #include <rte_eal.h>
  14 #include <rte_log.h>
  15 #include <rte_per_lcore.h>
  16
  17 #include "eal_private.h"
  18
  19 /* global log structure */
  20 struct rte_logs rte_logs = {
  21         .type = ~0,
  22         .level = RTE_LOG_DEBUG,
  23         .file = NULL,
  24 };
  25
  26 /** Global list of valid EAL log level options */
  27 struct rte_eal_opt_loglevel_list opt_loglevel_list =
  28         TAILQ_HEAD_INITIALIZER(opt_loglevel_list);
  29
  30 /* Stream to use for logging if rte_logs.file is NULL */
  31 static FILE *default_log_stream;
  32
  33 /**
  34  * This global structure stores some informations about the message
  35  * that is currently being processed by one lcore
  36  */
  37 struct log_cur_msg {
  38         uint32_t loglevel; /**< log level - see rte_log.h */
  39         uint32_t logtype;  /**< log type  - see rte_log.h */
  40 };
  41
  42 struct rte_log_dynamic_type {
  43         const char *name;
  44         uint32_t loglevel;
  45 };
  46
  47  /* per core log */
  48 static RTE_DEFINE_PER_LCORE(struct log_cur_msg, log_cur_msg);
  49
  50 /* default logs */
  51
  52 /* Change the stream that will be used by logging system */
  53 int
  54 rte_openlog_stream(FILE *f)
  55 {
  56         rte_logs.file = f;
  57         return 0;
  58 }
  59
  60 /* Set global log level */
  61 void
  62 rte_log_set_global_level(uint32_t level)
  63 {
  64         rte_logs.level = (uint32_t)level;
  65 }
  66
  67 /* Get global log level */
  68 uint32_t
  69 rte_log_get_global_level(void)
  70 {
  71         return rte_logs.level;
  72 }
  73
  74 int
  75 rte_log_get_level(uint32_t type)
  76 {
  77         if (type >= rte_logs.dynamic_types_len)
  78                 return -1;
  79
  80         return rte_logs.dynamic_types[type].loglevel;
  81 }
  82
  83 int
  84 rte_log_set_level(uint32_t type, uint32_t level)
  85 {
  86         if (type >= rte_logs.dynamic_types_len)
  87                 return -1;
  88         if (level > RTE_LOG_DEBUG)
  89                 return -1;
  90
  91         rte_logs.dynamic_types[type].loglevel = level;
  92
  93         return 0;
  94 }
  95
  96 /* set level */
  97 int
  98 rte_log_set_level_regexp(const char *pattern, uint32_t level)
  99 {
 100         regex_t r;
 101         size_t i;
 102
 103         if (level > RTE_LOG_DEBUG)
 104                 return -1;
 105
 106         if (regcomp(&r, pattern, 0) != 0)
 107                 return -1;
 108
 109         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 110                 if (rte_logs.dynamic_types[i].name == NULL)
 111                         continue;
 112                 if (regexec(&r, rte_logs.dynamic_types[i].name, 0,
 113                                 NULL, 0) == 0)
 114                         rte_logs.dynamic_types[i].loglevel = level;
 115         }
 116
 117         regfree(&r);
 118
 119         return 0;
 120 }
 121
 122 /* get the current loglevel for the message being processed */
 123 int rte_log_cur_msg_loglevel(void)
 124 {
 125         return RTE_PER_LCORE(log_cur_msg).loglevel;
 126 }
 127
 128 /* get the current logtype for the message being processed */
 129 int rte_log_cur_msg_logtype(void)
 130 {
 131         return RTE_PER_LCORE(log_cur_msg).logtype;
 132 }
 133
 134 static int
 135 rte_log_lookup(const char *name)
 136 {
 137         size_t i;
 138
 139         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 140                 if (rte_logs.dynamic_types[i].name == NULL)
 141                         continue;
 142                 if (strcmp(name, rte_logs.dynamic_types[i].name) == 0)
 143                         return i;
 144         }
 145
 146         return -1;
 147 }
 148
 149 /* register an extended log type, assuming table is large enough, and id
 150  * is not yet registered.
 151  */
 152 static int
 153 __rte_log_register(const char *name, int id)
 154 {
 155         char *dup_name = strdup(name);
 156
 157         if (dup_name == NULL)
 158                 return -ENOMEM;
 159
 160         rte_logs.dynamic_types[id].name = dup_name;
 161         rte_logs.dynamic_types[id].loglevel = RTE_LOG_INFO;
 162
 163         return id;
 164 }
 165
 166 /* register an extended log type */
 167 int
 168 rte_log_register(const char *name)
 169 {
 170         struct rte_log_dynamic_type *new_dynamic_types;
 171         int id, ret;
 172
 173         id = rte_log_lookup(name);
 174         if (id >= 0)
 175                 return id;
 176
 177         new_dynamic_types = realloc(rte_logs.dynamic_types,
 178                 sizeof(struct rte_log_dynamic_type) *
 179                 (rte_logs.dynamic_types_len + 1));
 180         if (new_dynamic_types == NULL)
 181                 return -ENOMEM;
 182         rte_logs.dynamic_types = new_dynamic_types;
 183
 184         ret = __rte_log_register(name, rte_logs.dynamic_types_len);
 185         if (ret < 0)
 186                 return ret;
 187
 188         rte_logs.dynamic_types_len++;
 189
 190         return ret;
 191 }
 192
 193 /* Register an extended log type and try to pick its level from EAL options */
 194 int __rte_experimental
 195 rte_log_register_type_and_pick_level(const char *name, uint32_t level_def)
 196 {
 197         struct rte_eal_opt_loglevel *opt_ll;
 198         uint32_t level = level_def;
 199         int type;
 200
 201         type = rte_log_register(name);
 202         if (type < 0)
 203                 return type;
 204
 205         TAILQ_FOREACH(opt_ll, &opt_loglevel_list, next) {
 206                 regex_t r;
 207
 208                 if (opt_ll->level > RTE_LOG_DEBUG)
 209                         continue;
 210
 211                 if (regcomp(&r, opt_ll->re_type, 0) != 0)
 212                         continue;
 213
 214                 if (regexec(&r, name, 0, NULL, 0) == 0)
 215                         level = opt_ll->level;
 216
 217                 regfree(&r);
 218         }
 219
 220         rte_logs.dynamic_types[type].loglevel = level;
 221
 222         return type;
 223 }
 224
 225 struct logtype {
 226         uint32_t log_id;
 227         const char *logtype;
 228 };
 229
 230 static const struct logtype logtype_strings[] = {
 231         {RTE_LOGTYPE_EAL,        "lib.eal"},
 232         {RTE_LOGTYPE_MALLOC,     "lib.malloc"},
 233         {RTE_LOGTYPE_RING,       "lib.ring"},
 234         {RTE_LOGTYPE_MEMPOOL,    "lib.mempool"},
 235         {RTE_LOGTYPE_TIMER,      "lib.timer"},
 236         {RTE_LOGTYPE_PMD,        "pmd"},
 237         {RTE_LOGTYPE_HASH,       "lib.hash"},
 238         {RTE_LOGTYPE_LPM,        "lib.lpm"},
 239         {RTE_LOGTYPE_KNI,        "lib.kni"},
 240         {RTE_LOGTYPE_ACL,        "lib.acl"},
 241         {RTE_LOGTYPE_POWER,      "lib.power"},
 242         {RTE_LOGTYPE_METER,      "lib.meter"},
 243         {RTE_LOGTYPE_SCHED,      "lib.sched"},
 244         {RTE_LOGTYPE_PORT,       "lib.port"},
 245         {RTE_LOGTYPE_TABLE,      "lib.table"},
 246         {RTE_LOGTYPE_PIPELINE,   "lib.pipeline"},
 247         {RTE_LOGTYPE_MBUF,       "lib.mbuf"},
 248         {RTE_LOGTYPE_CRYPTODEV,  "lib.cryptodev"},
 249         {RTE_LOGTYPE_EFD,        "lib.efd"},
 250         {RTE_LOGTYPE_EVENTDEV,   "lib.eventdev"},
 251         {RTE_LOGTYPE_GSO,        "lib.gso"},
 252         {RTE_LOGTYPE_USER1,      "user1"},
 253         {RTE_LOGTYPE_USER2,      "user2"},
 254         {RTE_LOGTYPE_USER3,      "user3"},
 255         {RTE_LOGTYPE_USER4,      "user4"},
 256         {RTE_LOGTYPE_USER5,      "user5"},
 257         {RTE_LOGTYPE_USER6,      "user6"},
 258         {RTE_LOGTYPE_USER7,      "user7"},
 259         {RTE_LOGTYPE_USER8,      "user8"}
 260 };
 261
 262 /* Logging should be first initializer (before drivers and bus) */
 263 RTE_INIT_PRIO(rte_log_init, 101);
 264 static void
 265 rte_log_init(void)
 266 {
 267         uint32_t i;
 268
 269         rte_log_set_global_level(RTE_LOG_DEBUG);
 270
 271         rte_logs.dynamic_types = calloc(RTE_LOGTYPE_FIRST_EXT_ID,
 272                 sizeof(struct rte_log_dynamic_type));
 273         if (rte_logs.dynamic_types == NULL)
 274                 return;
 275
 276         /* register legacy log types */
 277         for (i = 0; i < RTE_DIM(logtype_strings); i++)
 278                 __rte_log_register(logtype_strings[i].logtype,
 279                                 logtype_strings[i].log_id);
 280
 281         rte_logs.dynamic_types_len = RTE_LOGTYPE_FIRST_EXT_ID;
 282 }
 283
 284 static const char *
 285 loglevel_to_string(uint32_t level)
 286 {
 287         switch (level) {
 288         case 0: return "disabled";
 289         case RTE_LOG_EMERG: return "emerg";
 290         case RTE_LOG_ALERT: return "alert";
 291         case RTE_LOG_CRIT: return "critical";
 292         case RTE_LOG_ERR: return "error";
 293         case RTE_LOG_WARNING: return "warning";
 294         case RTE_LOG_NOTICE: return "notice";
 295         case RTE_LOG_INFO: return "info";
 296         case RTE_LOG_DEBUG: return "debug";
 297         default: return "unknown";
 298         }
 299 }
 300
 301 /* dump global level and registered log types */
 302 void
 303 rte_log_dump(FILE *f)
 304 {
 305         size_t i;
 306
 307         fprintf(f, "global log level is %s\n",
 308                 loglevel_to_string(rte_log_get_global_level()));
 309
 310         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 311                 if (rte_logs.dynamic_types[i].name == NULL)
 312                         continue;
 313                 fprintf(f, "id %zu: %s, level is %s\n",
 314                         i, rte_logs.dynamic_types[i].name,
 315                         loglevel_to_string(rte_logs.dynamic_types[i].loglevel));
 316         }
 317 }
 318
 319 /*
 320  * Generates a log message The message will be sent in the stream
 321  * defined by the previous call to rte_openlog_stream().
 322  */
 323 int
 324 rte_vlog(uint32_t level, uint32_t logtype, const char *format, va_list ap)
 325 {
 326         int ret;
 327         FILE *f = rte_logs.file;
 328         if (f == NULL) {
 329                 f = default_log_stream;
 330                 if (f == NULL) {
 331                         /*
 332                          * Grab the current value of stderr here, rather than
 333                          * just initializing default_log_stream to stderr. This
 334                          * ensures that we will always use the current value
 335                          * of stderr, even if the application closes and
 336                          * reopens it.
 337                          */
 338                         f = stderr;
 339                 }
 340         }
 341
 342         if (level > rte_logs.level)
 343                 return 0;
 344         if (logtype >= rte_logs.dynamic_types_len)
 345                 return -1;
 346         if (level > rte_logs.dynamic_types[logtype].loglevel)
 347                 return 0;
 348
 349         /* save loglevel and logtype in a global per-lcore variable */
 350         RTE_PER_LCORE(log_cur_msg).loglevel = level;
 351         RTE_PER_LCORE(log_cur_msg).logtype = logtype;
 352
 353         ret = vfprintf(f, format, ap);
 354         fflush(f);
 355         return ret;
 356 }
 357
 358 /*
 359  * Generates a log message The message will be sent in the stream
 360  * defined by the previous call to rte_openlog_stream().
 361  * No need to check level here, done by rte_vlog().
 362  */
 363 int
 364 rte_log(uint32_t level, uint32_t logtype, const char *format, ...)
 365 {
 366         va_list ap;
 367         int ret;
 368
 369         va_start(ap, format);
 370         ret = rte_vlog(level, logtype, format, ap);
 371         va_end(ap);
 372         return ret;
 373 }
 374
 375 /*
 376  * Called by environment-specific initialization functions.
 377  */
 378 void
 379 eal_log_set_default(FILE *default_log)
 380 {
 381         default_log_stream = default_log;
 382
 383 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 384         RTE_LOG(NOTICE, EAL,
 385                 "Debug dataplane logs available - lower performance\n");
 386 #endif
 387 }