lib/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 #include <fnmatch.h>
  13
  14 #include <rte_eal.h>
  15 #include <rte_log.h>
  16 #include <rte_os_shim.h>
  17 #include <rte_per_lcore.h>
  18
  19 #include "eal_log.h"
  20
  21 struct rte_log_dynamic_type {
  22         const char *name;
  23         uint32_t loglevel;
  24 };
  25
  26 /** The rte_log structure. */
  27 static struct rte_logs {
  28         uint32_t type;  /**< Bitfield with enabled logs. */
  29         uint32_t level; /**< Log level. */
  30         FILE *file;     /**< Output file set by rte_openlog_stream, or NULL. */
  31         size_t dynamic_types_len;
  32         struct rte_log_dynamic_type *dynamic_types;
  33 } rte_logs = {
  34         .type = UINT32_MAX,
  35         .level = RTE_LOG_DEBUG,
  36 };
  37
  38 struct rte_eal_opt_loglevel {
  39         /** Next list entry */
  40         TAILQ_ENTRY(rte_eal_opt_loglevel) next;
  41         /** Compiled regular expression obtained from the option */
  42         regex_t re_match;
  43         /** Globbing pattern option */
  44         char *pattern;
  45         /** Log level value obtained from the option */
  46         uint32_t level;
  47 };
  48
  49 TAILQ_HEAD(rte_eal_opt_loglevel_list, rte_eal_opt_loglevel);
  50
  51 /** List of valid EAL log level options */
  52 static struct rte_eal_opt_loglevel_list opt_loglevel_list =
  53         TAILQ_HEAD_INITIALIZER(opt_loglevel_list);
  54
  55 /* Stream to use for logging if rte_logs.file is NULL */
  56 static FILE *default_log_stream;
  57
  58 /**
  59  * This global structure stores some information about the message
  60  * that is currently being processed by one lcore
  61  */
  62 struct log_cur_msg {
  63         uint32_t loglevel; /**< log level - see rte_log.h */
  64         uint32_t logtype;  /**< log type  - see rte_log.h */
  65 };
  66
  67  /* per core log */
  68 static RTE_DEFINE_PER_LCORE(struct log_cur_msg, log_cur_msg);
  69
  70 /* default logs */
  71
  72 /* Change the stream that will be used by logging system */
  73 int
  74 rte_openlog_stream(FILE *f)
  75 {
  76         rte_logs.file = f;
  77         return 0;
  78 }
  79
  80 FILE *
  81 rte_log_get_stream(void)
  82 {
  83         FILE *f = rte_logs.file;
  84
  85         if (f == NULL) {
  86                 /*
  87                  * Grab the current value of stderr here, rather than
  88                  * just initializing default_log_stream to stderr. This
  89                  * ensures that we will always use the current value
  90                  * of stderr, even if the application closes and
  91                  * reopens it.
  92                  */
  93                 return default_log_stream ? : stderr;
  94         }
  95         return f;
  96 }
  97
  98 /* Set global log level */
  99 void
 100 rte_log_set_global_level(uint32_t level)
 101 {
 102         rte_logs.level = (uint32_t)level;
 103 }
 104
 105 /* Get global log level */
 106 uint32_t
 107 rte_log_get_global_level(void)
 108 {
 109         return rte_logs.level;
 110 }
 111
 112 int
 113 rte_log_get_level(uint32_t type)
 114 {
 115         if (type >= rte_logs.dynamic_types_len)
 116                 return -1;
 117
 118         return rte_logs.dynamic_types[type].loglevel;
 119 }
 120
 121 bool
 122 rte_log_can_log(uint32_t logtype, uint32_t level)
 123 {
 124         int log_level;
 125
 126         if (level > rte_log_get_global_level())
 127                 return false;
 128
 129         log_level = rte_log_get_level(logtype);
 130         if (log_level < 0)
 131                 return false;
 132
 133         if (level > (uint32_t)log_level)
 134                 return false;
 135
 136         return true;
 137 }
 138
 139 static void
 140 logtype_set_level(uint32_t type, uint32_t level)
 141 {
 142         uint32_t current = rte_logs.dynamic_types[type].loglevel;
 143
 144         if (current != level) {
 145                 rte_logs.dynamic_types[type].loglevel = level;
 146                 RTE_LOG(DEBUG, EAL, "%s log level changed from %s to %s\n",
 147                         rte_logs.dynamic_types[type].name == NULL ?
 148                                 "" : rte_logs.dynamic_types[type].name,
 149                         eal_log_level2str(current),
 150                         eal_log_level2str(level));
 151         }
 152 }
 153
 154 int
 155 rte_log_set_level(uint32_t type, uint32_t level)
 156 {
 157         if (type >= rte_logs.dynamic_types_len)
 158                 return -1;
 159         if (level > RTE_LOG_MAX)
 160                 return -1;
 161
 162         logtype_set_level(type, level);
 163
 164         return 0;
 165 }
 166
 167 /* set log level by regular expression */
 168 int
 169 rte_log_set_level_regexp(const char *regex, uint32_t level)
 170 {
 171         regex_t r;
 172         size_t i;
 173
 174         if (level > RTE_LOG_MAX)
 175                 return -1;
 176
 177         if (regcomp(&r, regex, 0) != 0)
 178                 return -1;
 179
 180         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 181                 if (rte_logs.dynamic_types[i].name == NULL)
 182                         continue;
 183                 if (regexec(&r, rte_logs.dynamic_types[i].name, 0,
 184                                 NULL, 0) == 0)
 185                         logtype_set_level(i, level);
 186         }
 187
 188         regfree(&r);
 189
 190         return 0;
 191 }
 192
 193 /*
 194  * Save the type string and the loglevel for later dynamic
 195  * logtypes which may register later.
 196  */
 197 static int
 198 log_save_level(uint32_t priority, const char *regex, const char *pattern)
 199 {
 200         struct rte_eal_opt_loglevel *opt_ll = NULL;
 201
 202         opt_ll = malloc(sizeof(*opt_ll));
 203         if (opt_ll == NULL)
 204                 goto fail;
 205
 206         opt_ll->level = priority;
 207
 208         if (regex) {
 209                 opt_ll->pattern = NULL;
 210                 if (regcomp(&opt_ll->re_match, regex, 0) != 0)
 211                         goto fail;
 212         } else if (pattern) {
 213                 opt_ll->pattern = strdup(pattern);
 214                 if (opt_ll->pattern == NULL)
 215                         goto fail;
 216         } else
 217                 goto fail;
 218
 219         TAILQ_INSERT_HEAD(&opt_loglevel_list, opt_ll, next);
 220         return 0;
 221 fail:
 222         free(opt_ll);
 223         return -1;
 224 }
 225
 226 int
 227 eal_log_save_regexp(const char *regex, uint32_t level)
 228 {
 229         return log_save_level(level, regex, NULL);
 230 }
 231
 232 /* set log level based on globbing pattern */
 233 int
 234 rte_log_set_level_pattern(const char *pattern, uint32_t level)
 235 {
 236         size_t i;
 237
 238         if (level > RTE_LOG_MAX)
 239                 return -1;
 240
 241         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 242                 if (rte_logs.dynamic_types[i].name == NULL)
 243                         continue;
 244
 245                 if (fnmatch(pattern, rte_logs.dynamic_types[i].name, 0) == 0)
 246                         logtype_set_level(i, level);
 247         }
 248
 249         return 0;
 250 }
 251
 252 int
 253 eal_log_save_pattern(const char *pattern, uint32_t level)
 254 {
 255         return log_save_level(level, NULL, pattern);
 256 }
 257
 258 /* get the current loglevel for the message being processed */
 259 int rte_log_cur_msg_loglevel(void)
 260 {
 261         return RTE_PER_LCORE(log_cur_msg).loglevel;
 262 }
 263
 264 /* get the current logtype for the message being processed */
 265 int rte_log_cur_msg_logtype(void)
 266 {
 267         return RTE_PER_LCORE(log_cur_msg).logtype;
 268 }
 269
 270 static int
 271 log_lookup(const char *name)
 272 {
 273         size_t i;
 274
 275         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 276                 if (rte_logs.dynamic_types[i].name == NULL)
 277                         continue;
 278                 if (strcmp(name, rte_logs.dynamic_types[i].name) == 0)
 279                         return i;
 280         }
 281
 282         return -1;
 283 }
 284
 285 static int
 286 log_register(const char *name, uint32_t level)
 287 {
 288         struct rte_log_dynamic_type *new_dynamic_types;
 289         int id;
 290
 291         id = log_lookup(name);
 292         if (id >= 0)
 293                 return id;
 294
 295         new_dynamic_types = realloc(rte_logs.dynamic_types,
 296                 sizeof(struct rte_log_dynamic_type) *
 297                 (rte_logs.dynamic_types_len + 1));
 298         if (new_dynamic_types == NULL)
 299                 return -ENOMEM;
 300         rte_logs.dynamic_types = new_dynamic_types;
 301
 302         id = rte_logs.dynamic_types_len;
 303         memset(&rte_logs.dynamic_types[id], 0,
 304                 sizeof(rte_logs.dynamic_types[id]));
 305         rte_logs.dynamic_types[id].name = strdup(name);
 306         if (rte_logs.dynamic_types[id].name == NULL)
 307                 return -ENOMEM;
 308         logtype_set_level(id, level);
 309
 310         rte_logs.dynamic_types_len++;
 311
 312         return id;
 313 }
 314
 315 /* register an extended log type */
 316 int
 317 rte_log_register(const char *name)
 318 {
 319         return log_register(name, RTE_LOG_INFO);
 320 }
 321
 322 /* Register an extended log type and try to pick its level from EAL options */
 323 int
 324 rte_log_register_type_and_pick_level(const char *name, uint32_t level_def)
 325 {
 326         struct rte_eal_opt_loglevel *opt_ll;
 327         uint32_t level = level_def;
 328
 329         TAILQ_FOREACH(opt_ll, &opt_loglevel_list, next) {
 330                 if (opt_ll->level > RTE_LOG_MAX)
 331                         continue;
 332
 333                 if (opt_ll->pattern) {
 334                         if (fnmatch(opt_ll->pattern, name, 0) == 0)
 335                                 level = opt_ll->level;
 336                 } else {
 337                         if (regexec(&opt_ll->re_match, name, 0, NULL, 0) == 0)
 338                                 level = opt_ll->level;
 339                 }
 340         }
 341
 342         return log_register(name, level);
 343 }
 344
 345 struct logtype {
 346         uint32_t log_id;
 347         const char *logtype;
 348 };
 349
 350 static const struct logtype logtype_strings[] = {
 351         {RTE_LOGTYPE_EAL,        "lib.eal"},
 352         {RTE_LOGTYPE_MALLOC,     "lib.malloc"},
 353         {RTE_LOGTYPE_RING,       "lib.ring"},
 354         {RTE_LOGTYPE_MEMPOOL,    "lib.mempool"},
 355         {RTE_LOGTYPE_TIMER,      "lib.timer"},
 356         {RTE_LOGTYPE_PMD,        "pmd"},
 357         {RTE_LOGTYPE_HASH,       "lib.hash"},
 358         {RTE_LOGTYPE_LPM,        "lib.lpm"},
 359         {RTE_LOGTYPE_KNI,        "lib.kni"},
 360         {RTE_LOGTYPE_ACL,        "lib.acl"},
 361         {RTE_LOGTYPE_POWER,      "lib.power"},
 362         {RTE_LOGTYPE_METER,      "lib.meter"},
 363         {RTE_LOGTYPE_SCHED,      "lib.sched"},
 364         {RTE_LOGTYPE_PORT,       "lib.port"},
 365         {RTE_LOGTYPE_TABLE,      "lib.table"},
 366         {RTE_LOGTYPE_PIPELINE,   "lib.pipeline"},
 367         {RTE_LOGTYPE_MBUF,       "lib.mbuf"},
 368         {RTE_LOGTYPE_CRYPTODEV,  "lib.cryptodev"},
 369         {RTE_LOGTYPE_EFD,        "lib.efd"},
 370         {RTE_LOGTYPE_EVENTDEV,   "lib.eventdev"},
 371         {RTE_LOGTYPE_GSO,        "lib.gso"},
 372         {RTE_LOGTYPE_USER1,      "user1"},
 373         {RTE_LOGTYPE_USER2,      "user2"},
 374         {RTE_LOGTYPE_USER3,      "user3"},
 375         {RTE_LOGTYPE_USER4,      "user4"},
 376         {RTE_LOGTYPE_USER5,      "user5"},
 377         {RTE_LOGTYPE_USER6,      "user6"},
 378         {RTE_LOGTYPE_USER7,      "user7"},
 379         {RTE_LOGTYPE_USER8,      "user8"}
 380 };
 381
 382 /* Logging should be first initializer (before drivers and bus) */
 383 RTE_INIT_PRIO(log_init, LOG)
 384 {
 385         uint32_t i;
 386
 387         rte_log_set_global_level(RTE_LOG_DEBUG);
 388
 389         rte_logs.dynamic_types = calloc(RTE_LOGTYPE_FIRST_EXT_ID,
 390                 sizeof(struct rte_log_dynamic_type));
 391         if (rte_logs.dynamic_types == NULL)
 392                 return;
 393
 394         /* register legacy log types */
 395         for (i = 0; i < RTE_DIM(logtype_strings); i++) {
 396                 rte_logs.dynamic_types[logtype_strings[i].log_id].name =
 397                         strdup(logtype_strings[i].logtype);
 398                 logtype_set_level(logtype_strings[i].log_id, RTE_LOG_INFO);
 399         }
 400
 401         rte_logs.dynamic_types_len = RTE_LOGTYPE_FIRST_EXT_ID;
 402 }
 403
 404 const char *
 405 eal_log_level2str(uint32_t level)
 406 {
 407         switch (level) {
 408         case 0: return "disabled";
 409         case RTE_LOG_EMERG: return "emergency";
 410         case RTE_LOG_ALERT: return "alert";
 411         case RTE_LOG_CRIT: return "critical";
 412         case RTE_LOG_ERR: return "error";
 413         case RTE_LOG_WARNING: return "warning";
 414         case RTE_LOG_NOTICE: return "notice";
 415         case RTE_LOG_INFO: return "info";
 416         case RTE_LOG_DEBUG: return "debug";
 417         default: return "unknown";
 418         }
 419 }
 420
 421 static int
 422 log_type_compare(const void *a, const void *b)
 423 {
 424         const struct rte_log_dynamic_type *type_a = a;
 425         const struct rte_log_dynamic_type *type_b = b;
 426
 427         if (type_a->name == NULL && type_b->name == NULL)
 428                 return 0;
 429         if (type_a->name == NULL)
 430                 return -1;
 431         if (type_b->name == NULL)
 432                 return 1;
 433         return strcmp(type_a->name, type_b->name);
 434 }
 435
 436 /* Dump name of each logtype, one per line. */
 437 void
 438 rte_log_list_types(FILE *out, const char *prefix)
 439 {
 440         struct rte_log_dynamic_type *sorted_types;
 441         const size_t type_size = sizeof(rte_logs.dynamic_types[0]);
 442         const size_t type_count = rte_logs.dynamic_types_len;
 443         const size_t total_size = type_size * type_count;
 444         size_t type;
 445
 446         sorted_types = malloc(total_size);
 447         if (sorted_types == NULL) {
 448                 /* no sorting - unlikely */
 449                 sorted_types = rte_logs.dynamic_types;
 450         } else {
 451                 memcpy(sorted_types, rte_logs.dynamic_types, total_size);
 452                 qsort(sorted_types, type_count, type_size, log_type_compare);
 453         }
 454
 455         for (type = 0; type < type_count; ++type) {
 456                 if (sorted_types[type].name == NULL)
 457                         continue;
 458                 fprintf(out, "%s%s\n", prefix, sorted_types[type].name);
 459         }
 460
 461         if (sorted_types != rte_logs.dynamic_types)
 462                 free(sorted_types);
 463 }
 464
 465 /* dump global level and registered log types */
 466 void
 467 rte_log_dump(FILE *f)
 468 {
 469         size_t i;
 470
 471         fprintf(f, "global log level is %s\n",
 472                 eal_log_level2str(rte_log_get_global_level()));
 473
 474         for (i = 0; i < rte_logs.dynamic_types_len; i++) {
 475                 if (rte_logs.dynamic_types[i].name == NULL)
 476                         continue;
 477                 fprintf(f, "id %zu: %s, level is %s\n",
 478                         i, rte_logs.dynamic_types[i].name,
 479                         eal_log_level2str(rte_logs.dynamic_types[i].loglevel));
 480         }
 481 }
 482
 483 /*
 484  * Generates a log message The message will be sent in the stream
 485  * defined by the previous call to rte_openlog_stream().
 486  */
 487 int
 488 rte_vlog(uint32_t level, uint32_t logtype, const char *format, va_list ap)
 489 {
 490         FILE *f = rte_log_get_stream();
 491         int ret;
 492
 493         if (logtype >= rte_logs.dynamic_types_len)
 494                 return -1;
 495         if (!rte_log_can_log(logtype, level))
 496                 return 0;
 497
 498         /* save loglevel and logtype in a global per-lcore variable */
 499         RTE_PER_LCORE(log_cur_msg).loglevel = level;
 500         RTE_PER_LCORE(log_cur_msg).logtype = logtype;
 501
 502         ret = vfprintf(f, format, ap);
 503         fflush(f);
 504         return ret;
 505 }
 506
 507 /*
 508  * Generates a log message The message will be sent in the stream
 509  * defined by the previous call to rte_openlog_stream().
 510  * No need to check level here, done by rte_vlog().
 511  */
 512 int
 513 rte_log(uint32_t level, uint32_t logtype, const char *format, ...)
 514 {
 515         va_list ap;
 516         int ret;
 517
 518         va_start(ap, format);
 519         ret = rte_vlog(level, logtype, format, ap);
 520         va_end(ap);
 521         return ret;
 522 }
 523
 524 /*
 525  * Called by environment-specific initialization functions.
 526  */
 527 void
 528 eal_log_set_default(FILE *default_log)
 529 {
 530         default_log_stream = default_log;
 531
 532 #if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
 533         RTE_LOG(NOTICE, EAL,
 534                 "Debug dataplane logs available - lower performance\n");
 535 #endif
 536 }