1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2017 Intel Corporation 3 */ 4 5 #ifndef _RTE_LOG_H_ 6 #define _RTE_LOG_H_ 7 8 /** 9 * @file 10 * 11 * RTE Logs API 12 * 13 * This file provides a log API to RTE applications. 14 */ 15 16 #ifdef __cplusplus 17 extern "C" { 18 #endif 19 20 #include <stdint.h> 21 #include <stdio.h> 22 #include <stdarg.h> 23 #include <stdbool.h> 24 #include <sys/queue.h> 25 26 #include <rte_common.h> 27 #include <rte_config.h> 28 #include <rte_compat.h> 29 30 /* SDK log type */ 31 #define RTE_LOGTYPE_EAL 0 /**< Log related to eal. */ 32 #define RTE_LOGTYPE_MALLOC 1 /**< Log related to malloc. */ 33 #define RTE_LOGTYPE_RING 2 /**< Log related to ring. */ 34 #define RTE_LOGTYPE_MEMPOOL 3 /**< Log related to mempool. */ 35 #define RTE_LOGTYPE_TIMER 4 /**< Log related to timers. */ 36 #define RTE_LOGTYPE_PMD 5 /**< Log related to poll mode driver. */ 37 #define RTE_LOGTYPE_HASH 6 /**< Log related to hash table. */ 38 #define RTE_LOGTYPE_LPM 7 /**< Log related to LPM. */ 39 #define RTE_LOGTYPE_KNI 8 /**< Log related to KNI. */ 40 #define RTE_LOGTYPE_ACL 9 /**< Log related to ACL. */ 41 #define RTE_LOGTYPE_POWER 10 /**< Log related to power. */ 42 #define RTE_LOGTYPE_METER 11 /**< Log related to QoS meter. */ 43 #define RTE_LOGTYPE_SCHED 12 /**< Log related to QoS port scheduler. */ 44 #define RTE_LOGTYPE_PORT 13 /**< Log related to port. */ 45 #define RTE_LOGTYPE_TABLE 14 /**< Log related to table. */ 46 #define RTE_LOGTYPE_PIPELINE 15 /**< Log related to pipeline. */ 47 #define RTE_LOGTYPE_MBUF 16 /**< Log related to mbuf. */ 48 #define RTE_LOGTYPE_CRYPTODEV 17 /**< Log related to cryptodev. */ 49 #define RTE_LOGTYPE_EFD 18 /**< Log related to EFD. */ 50 #define RTE_LOGTYPE_EVENTDEV 19 /**< Log related to eventdev. */ 51 #define RTE_LOGTYPE_GSO 20 /**< Log related to GSO. */ 52 53 /* these log types can be used in an application */ 54 #define RTE_LOGTYPE_USER1 24 /**< User-defined log type 1. */ 55 #define RTE_LOGTYPE_USER2 25 /**< User-defined log type 2. */ 56 #define RTE_LOGTYPE_USER3 26 /**< User-defined log type 3. */ 57 #define RTE_LOGTYPE_USER4 27 /**< User-defined log type 4. */ 58 #define RTE_LOGTYPE_USER5 28 /**< User-defined log type 5. */ 59 #define RTE_LOGTYPE_USER6 29 /**< User-defined log type 6. */ 60 #define RTE_LOGTYPE_USER7 30 /**< User-defined log type 7. */ 61 #define RTE_LOGTYPE_USER8 31 /**< User-defined log type 8. */ 62 63 /** First identifier for extended logs */ 64 #define RTE_LOGTYPE_FIRST_EXT_ID 32 65 66 /* Can't use 0, as it gives compiler warnings */ 67 #define RTE_LOG_EMERG 1U /**< System is unusable. */ 68 #define RTE_LOG_ALERT 2U /**< Action must be taken immediately. */ 69 #define RTE_LOG_CRIT 3U /**< Critical conditions. */ 70 #define RTE_LOG_ERR 4U /**< Error conditions. */ 71 #define RTE_LOG_WARNING 5U /**< Warning conditions. */ 72 #define RTE_LOG_NOTICE 6U /**< Normal but significant condition. */ 73 #define RTE_LOG_INFO 7U /**< Informational. */ 74 #define RTE_LOG_DEBUG 8U /**< Debug-level messages. */ 75 76 /** 77 * Change the stream that will be used by the logging system. 78 * 79 * This can be done at any time. The f argument represents the stream 80 * to be used to send the logs. If f is NULL, the default output is 81 * used (stderr). 82 * 83 * @param f 84 * Pointer to the stream. 85 * @return 86 * - 0 on success. 87 * - Negative on error. 88 */ 89 int rte_openlog_stream(FILE *f); 90 91 /** 92 * Retrieve the stream used by the logging system (see rte_openlog_stream() 93 * to change it). 94 * 95 * @return 96 * Pointer to the stream. 97 */ 98 FILE *rte_log_get_stream(void); 99 100 /** 101 * Set the global log level. 102 * 103 * After this call, logs with a level lower or equal than the level 104 * passed as argument will be displayed. 105 * 106 * @param level 107 * Log level. A value between RTE_LOG_EMERG (1) and RTE_LOG_DEBUG (8). 108 */ 109 void rte_log_set_global_level(uint32_t level); 110 111 /** 112 * Get the global log level. 113 * 114 * @return 115 * The current global log level. 116 */ 117 uint32_t rte_log_get_global_level(void); 118 119 /** 120 * Get the log level for a given type. 121 * 122 * @param logtype 123 * The log type identifier. 124 * @return 125 * 0 on success, a negative value if logtype is invalid. 126 */ 127 int rte_log_get_level(uint32_t logtype); 128 129 /** 130 * For a given `logtype`, check if a log with `loglevel` can be printed. 131 * 132 * @param logtype 133 * The log type identifier 134 * @param loglevel 135 * Log level. A value between RTE_LOG_EMERG (1) and RTE_LOG_DEBUG (8). 136 * @return 137 * Returns 'true' if log can be printed and 'false' if it can't. 138 */ 139 __rte_experimental 140 bool rte_log_can_log(uint32_t logtype, uint32_t loglevel); 141 142 /** 143 * Set the log level for a given type based on globbing pattern. 144 * 145 * @param pattern 146 * The globbing pattern identifying the log type. 147 * @param level 148 * The level to be set. 149 * @return 150 * 0 on success, a negative value if level is invalid. 151 */ 152 int rte_log_set_level_pattern(const char *pattern, uint32_t level); 153 154 /** 155 * Set the log level for a given type based on regular expression. 156 * 157 * @param regex 158 * The regular expression identifying the log type. 159 * @param level 160 * The level to be set. 161 * @return 162 * 0 on success, a negative value if level is invalid. 163 */ 164 int rte_log_set_level_regexp(const char *regex, uint32_t level); 165 166 /** 167 * Set the log level for a given type. 168 * 169 * @param logtype 170 * The log type identifier. 171 * @param level 172 * The level to be set. 173 * @return 174 * 0 on success, a negative value if logtype or level is invalid. 175 */ 176 int rte_log_set_level(uint32_t logtype, uint32_t level); 177 178 /** 179 * Get the current loglevel for the message being processed. 180 * 181 * Before calling the user-defined stream for logging, the log 182 * subsystem sets a per-lcore variable containing the loglevel and the 183 * logtype of the message being processed. This information can be 184 * accessed by the user-defined log output function through this 185 * function. 186 * 187 * @return 188 * The loglevel of the message being processed. 189 */ 190 int rte_log_cur_msg_loglevel(void); 191 192 /** 193 * Get the current logtype for the message being processed. 194 * 195 * Before calling the user-defined stream for logging, the log 196 * subsystem sets a per-lcore variable containing the loglevel and the 197 * logtype of the message being processed. This information can be 198 * accessed by the user-defined log output function through this 199 * function. 200 * 201 * @return 202 * The logtype of the message being processed. 203 */ 204 int rte_log_cur_msg_logtype(void); 205 206 /** 207 * Register a dynamic log type 208 * 209 * If a log is already registered with the same type, the returned value 210 * is the same than the previous one. 211 * 212 * @param name 213 * The string identifying the log type. 214 * @return 215 * - >0: success, the returned value is the log type identifier. 216 * - (-ENOMEM): cannot allocate memory. 217 */ 218 int rte_log_register(const char *name); 219 220 /** 221 * @warning 222 * @b EXPERIMENTAL: this API may change without prior notice 223 * 224 * Register a dynamic log type and try to pick its level from EAL options 225 * 226 * rte_log_register() is called inside. If successful, the function tries 227 * to search for matching regexp in the list of EAL log level options and 228 * pick the level from the last matching entry. If nothing can be applied 229 * from the list, the level will be set to the user-defined default value. 230 * 231 * @param name 232 * Name for the log type to be registered 233 * @param level_def 234 * Fallback level to be set if the global list has no matching options 235 * @return 236 * - >=0: the newly registered log type 237 * - <0: rte_log_register() error value 238 */ 239 __rte_experimental 240 int rte_log_register_type_and_pick_level(const char *name, uint32_t level_def); 241 242 /** 243 * Dump log information. 244 * 245 * Dump the global level and the registered log types. 246 * 247 * @param f 248 * The output stream where the dump should be sent. 249 */ 250 void rte_log_dump(FILE *f); 251 252 /** 253 * Generates a log message. 254 * 255 * The message will be sent in the stream defined by the previous call 256 * to rte_openlog_stream(). 257 * 258 * The level argument determines if the log should be displayed or 259 * not, depending on the loglevel settings. 260 * 261 * The preferred alternative is the RTE_LOG() because it adds the 262 * level and type in the logged string. 263 * 264 * @param level 265 * Log level. A value between RTE_LOG_EMERG (1) and RTE_LOG_DEBUG (8). 266 * @param logtype 267 * The log type, for example, RTE_LOGTYPE_EAL. 268 * @param format 269 * The format string, as in printf(3), followed by the variable arguments 270 * required by the format. 271 * @return 272 * - 0: Success. 273 * - Negative on error. 274 */ 275 int rte_log(uint32_t level, uint32_t logtype, const char *format, ...) 276 #ifdef __GNUC__ 277 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) 278 __rte_cold 279 #endif 280 #endif 281 __rte_format_printf(3, 4); 282 283 /** 284 * Generates a log message. 285 * 286 * The message will be sent in the stream defined by the previous call 287 * to rte_openlog_stream(). 288 * 289 * The level argument determines if the log should be displayed or 290 * not, depending on the loglevel settings. A trailing 291 * newline may be added if needed. 292 * 293 * The preferred alternative is the RTE_LOG() because it adds the 294 * level and type in the logged string. 295 * 296 * @param level 297 * Log level. A value between RTE_LOG_EMERG (1) and RTE_LOG_DEBUG (8). 298 * @param logtype 299 * The log type, for example, RTE_LOGTYPE_EAL. 300 * @param format 301 * The format string, as in printf(3), followed by the variable arguments 302 * required by the format. 303 * @param ap 304 * The va_list of the variable arguments required by the format. 305 * @return 306 * - 0: Success. 307 * - Negative on error. 308 */ 309 int rte_vlog(uint32_t level, uint32_t logtype, const char *format, va_list ap) 310 __rte_format_printf(3, 0); 311 312 /** 313 * Generates a log message. 314 * 315 * The RTE_LOG() is a helper that prefixes the string with the log level 316 * and type, and call rte_log(). 317 * 318 * @param l 319 * Log level. A value between EMERG (1) and DEBUG (8). The short name is 320 * expanded by the macro, so it cannot be an integer value. 321 * @param t 322 * The log type, for example, EAL. The short name is expanded by the 323 * macro, so it cannot be an integer value. 324 * @param ... 325 * The fmt string, as in printf(3), followed by the variable arguments 326 * required by the format. 327 * @return 328 * - 0: Success. 329 * - Negative on error. 330 */ 331 #define RTE_LOG(l, t, ...) \ 332 rte_log(RTE_LOG_ ## l, \ 333 RTE_LOGTYPE_ ## t, # t ": " __VA_ARGS__) 334 335 /** 336 * Generates a log message for data path. 337 * 338 * Similar to RTE_LOG(), except that it is removed at compilation time 339 * if the RTE_LOG_DP_LEVEL configuration option is lower than the log 340 * level argument. 341 * 342 * @param l 343 * Log level. A value between EMERG (1) and DEBUG (8). The short name is 344 * expanded by the macro, so it cannot be an integer value. 345 * @param t 346 * The log type, for example, EAL. The short name is expanded by the 347 * macro, so it cannot be an integer value. 348 * @param ... 349 * The fmt string, as in printf(3), followed by the variable arguments 350 * required by the format. 351 * @return 352 * - 0: Success. 353 * - Negative on error. 354 */ 355 #define RTE_LOG_DP(l, t, ...) \ 356 (void)((RTE_LOG_ ## l <= RTE_LOG_DP_LEVEL) ? \ 357 rte_log(RTE_LOG_ ## l, \ 358 RTE_LOGTYPE_ ## t, # t ": " __VA_ARGS__) : \ 359 0) 360 361 /** 362 * @warning 363 * @b EXPERIMENTAL: this API may change without prior notice 364 * 365 * Register a dynamic log type in constructor context with its name and level. 366 * 367 * It is a wrapper macro for declaring the logtype, register the log and 368 * sets it's level in the constructor context. 369 * 370 * @param type 371 * The log type identifier 372 * @param name 373 * Name for the log type to be registered 374 * @param level 375 * Log level. A value between EMERG (1) and DEBUG (8). 376 */ 377 #define RTE_LOG_REGISTER(type, name, level) \ 378 int type; \ 379 RTE_INIT(__##type) \ 380 { \ 381 type = rte_log_register_type_and_pick_level(RTE_STR(name), \ 382 RTE_LOG_##level); \ 383 } 384 385 #ifdef __cplusplus 386 } 387 #endif 388 389 #endif /* _RTE_LOG_H_ */ 390