New upstream version 18.08

[deb_dpdk.git] / lib / librte_eal / common / eal_common_log.c

diff --git a/lib/librte_eal/common/eal_common_log.c b/lib/librte_eal/common/eal_common_log.c
index 37b2e20..c714a4b 100644 (file)
--- a/lib/librte_eal/common/eal_common_log.c
+++ b/lib/librte_eal/common/eal_common_log.c
@@ -9,6 +9,7 @@
 #include <string.h>
 #include <errno.h>
 #include <regex.h>
+#include <fnmatch.h>
 
 #include <rte_eal.h>
 #include <rte_log.h>
@@ -23,6 +24,23 @@ struct rte_logs rte_logs = {
        .file = NULL,
 };
 
+struct rte_eal_opt_loglevel {
+       /** Next list entry */
+       TAILQ_ENTRY(rte_eal_opt_loglevel) next;
+       /** Compiled regular expression obtained from the option */
+       regex_t re_match;
+       /** Glob match string option */
+       char *pattern;
+       /** Log level value obtained from the option */
+       uint32_t level;
+};
+
+TAILQ_HEAD(rte_eal_opt_loglevel_list, rte_eal_opt_loglevel);
+
+/** List of valid EAL log level options */
+static struct rte_eal_opt_loglevel_list opt_loglevel_list =
+       TAILQ_HEAD_INITIALIZER(opt_loglevel_list);
+
 /* Stream to use for logging if rte_logs.file is NULL */
 static FILE *default_log_stream;
 
@@ -89,9 +107,9 @@ rte_log_set_level(uint32_t type, uint32_t level)
        return 0;
 }
 
-/* set level */
+/* set log level by regular expression */
 int
-rte_log_set_level_regexp(const char *pattern, uint32_t level)
+rte_log_set_level_regexp(const char *regex, uint32_t level)
 {
        regex_t r;
        size_t i;
@@ -99,7 +117,7 @@ rte_log_set_level_regexp(const char *pattern, uint32_t level)
        if (level > RTE_LOG_DEBUG)
                return -1;
 
-       if (regcomp(&r, pattern, 0) != 0)
+       if (regcomp(&r, regex, 0) != 0)
                return -1;
 
        for (i = 0; i < rte_logs.dynamic_types_len; i++) {
@@ -115,6 +133,69 @@ rte_log_set_level_regexp(const char *pattern, uint32_t level)
        return 0;
 }
 
+/*
+ * Save the type string and the loglevel for later dynamic
+ * logtypes which may register later.
+ */
+static int rte_log_save_level(int priority,
+                             const char *regex, const char *pattern)
+{
+       struct rte_eal_opt_loglevel *opt_ll = NULL;
+
+       opt_ll = malloc(sizeof(*opt_ll));
+       if (opt_ll == NULL)
+               goto fail;
+
+       opt_ll->level = priority;
+
+       if (regex) {
+               opt_ll->pattern = NULL;
+               if (regcomp(&opt_ll->re_match, regex, 0) != 0)
+                       goto fail;
+       } else if (pattern) {
+               opt_ll->pattern = strdup(pattern);
+               if (opt_ll->pattern == NULL)
+                       goto fail;
+       } else
+               goto fail;
+
+       TAILQ_INSERT_HEAD(&opt_loglevel_list, opt_ll, next);
+       return 0;
+fail:
+       free(opt_ll);
+       return -1;
+}
+
+int rte_log_save_regexp(const char *regex, int tmp)
+{
+       return rte_log_save_level(tmp, regex, NULL);
+}
+
+/* set log level based on glob (file match) pattern */
+int
+rte_log_set_level_pattern(const char *pattern, uint32_t level)
+{
+       size_t i;
+
+       if (level > RTE_LOG_DEBUG)
+               return -1;
+
+       for (i = 0; i < rte_logs.dynamic_types_len; i++) {
+               if (rte_logs.dynamic_types[i].name == NULL)
+                       continue;
+
+               if (fnmatch(pattern, rte_logs.dynamic_types[i].name, 0) == 0)
+                       rte_logs.dynamic_types[i].loglevel = level;
+       }
+
+       return 0;
+}
+
+int rte_log_save_pattern(const char *pattern, int priority)
+{
+       return rte_log_save_level(priority, NULL, pattern);
+}
+
 /* get the current loglevel for the message being processed */
 int rte_log_cur_msg_loglevel(void)
 {
@@ -186,6 +267,36 @@ rte_log_register(const char *name)
        return ret;
 }
 
+/* Register an extended log type and try to pick its level from EAL options */
+int __rte_experimental
+rte_log_register_type_and_pick_level(const char *name, uint32_t level_def)
+{
+       struct rte_eal_opt_loglevel *opt_ll;
+       uint32_t level = level_def;
+       int type;
+
+       type = rte_log_register(name);
+       if (type < 0)
+               return type;
+
+       TAILQ_FOREACH(opt_ll, &opt_loglevel_list, next) {
+               if (opt_ll->level > RTE_LOG_DEBUG)
+                       continue;
+
+               if (opt_ll->pattern) {
+                       if (fnmatch(opt_ll->pattern, name, 0))
+                               level = opt_ll->level;
+               } else {
+                       if (regexec(&opt_ll->re_match, name, 0, NULL, 0) == 0)
+                               level = opt_ll->level;
+               }
+       }
+
+       rte_logs.dynamic_types[type].loglevel = level;
+
+       return type;
+}
+
 struct logtype {
        uint32_t log_id;
        const char *logtype;
@@ -224,9 +335,7 @@ static const struct logtype logtype_strings[] = {
 };
 
 /* Logging should be first initializer (before drivers and bus) */
-RTE_INIT_PRIO(rte_log_init, 101);
-static void
-rte_log_init(void)
+RTE_INIT_PRIO(rte_log_init, LOG)
 {
        uint32_t i;