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