src/bin/lttng/loglevel.cpp

   1 /*
   2  * Copyright (C) 2021 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include "loglevel.hpp"
   9
  10 #include <ctype.h>
  11 #include <string.h>
  12 #include <strings.h>
  13
  14 namespace {
  15 struct loglevel_name_value {
  16         const char *name;
  17         int value;
  18 };
  19 } /* namespace */
  20
  21 static const struct loglevel_name_value loglevel_values[] = {
  22         { .name = "EMERG", .value = LTTNG_LOGLEVEL_EMERG },
  23         { .name = "TRACE_EMERG", .value = LTTNG_LOGLEVEL_EMERG },
  24         { .name = "ALERT", .value = LTTNG_LOGLEVEL_ALERT },
  25         { .name = "TRACE_ALERT", .value = LTTNG_LOGLEVEL_ALERT },
  26         { .name = "CRIT", .value = LTTNG_LOGLEVEL_CRIT },
  27         { .name = "TRACE_CRIT", .value = LTTNG_LOGLEVEL_CRIT },
  28         { .name = "ERR", .value = LTTNG_LOGLEVEL_ERR },
  29         { .name = "TRACE_ERR", .value = LTTNG_LOGLEVEL_ERR },
  30         { .name = "WARNING", .value = LTTNG_LOGLEVEL_WARNING },
  31         { .name = "TRACE_WARNING", .value = LTTNG_LOGLEVEL_WARNING },
  32         { .name = "NOTICE", .value = LTTNG_LOGLEVEL_NOTICE },
  33         { .name = "TRACE_NOTICE", .value = LTTNG_LOGLEVEL_NOTICE },
  34         { .name = "INFO", .value = LTTNG_LOGLEVEL_INFO },
  35         { .name = "TRACE_INFO", .value = LTTNG_LOGLEVEL_INFO },
  36         { .name = "DEBUG_SYSTEM", .value = LTTNG_LOGLEVEL_DEBUG_SYSTEM },
  37         { .name = "TRACE_DEBUG_SYSTEM", .value = LTTNG_LOGLEVEL_DEBUG_SYSTEM },
  38         { .name = "SYSTEM", .value = LTTNG_LOGLEVEL_DEBUG_SYSTEM },
  39         { .name = "DEBUG_PROGRAM", .value = LTTNG_LOGLEVEL_DEBUG_PROGRAM },
  40         { .name = "TRACE_DEBUG_PROGRAM", .value = LTTNG_LOGLEVEL_DEBUG_PROGRAM },
  41         { .name = "PROGRAM", .value = LTTNG_LOGLEVEL_DEBUG_PROGRAM },
  42         { .name = "DEBUG_PROCESS", .value = LTTNG_LOGLEVEL_DEBUG_PROCESS },
  43         { .name = "TRACE_DEBUG_PROCESS", .value = LTTNG_LOGLEVEL_DEBUG_PROCESS },
  44         { .name = "PROCESS", .value = LTTNG_LOGLEVEL_DEBUG_PROCESS },
  45         { .name = "DEBUG_MODULE", .value = LTTNG_LOGLEVEL_DEBUG_MODULE },
  46         { .name = "TRACE_DEBUG_MODULE", .value = LTTNG_LOGLEVEL_DEBUG_MODULE },
  47         { .name = "MODULE", .value = LTTNG_LOGLEVEL_DEBUG_MODULE },
  48         { .name = "DEBUG_UNIT", .value = LTTNG_LOGLEVEL_DEBUG_UNIT },
  49         { .name = "TRACE_DEBUG_UNIT", .value = LTTNG_LOGLEVEL_DEBUG_UNIT },
  50         { .name = "UNIT", .value = LTTNG_LOGLEVEL_DEBUG_UNIT },
  51         { .name = "DEBUG_FUNCTION", .value = LTTNG_LOGLEVEL_DEBUG_FUNCTION },
  52         { .name = "TRACE_DEBUG_FUNCTION", .value = LTTNG_LOGLEVEL_DEBUG_FUNCTION },
  53         { .name = "FUNCTION", .value = LTTNG_LOGLEVEL_DEBUG_FUNCTION },
  54         { .name = "DEBUG_LINE", .value = LTTNG_LOGLEVEL_DEBUG_LINE },
  55         { .name = "TRACE_DEBUG_LINE", .value = LTTNG_LOGLEVEL_DEBUG_LINE },
  56         { .name = "LINE", .value = LTTNG_LOGLEVEL_DEBUG_LINE },
  57         { .name = "DEBUG", .value = LTTNG_LOGLEVEL_DEBUG },
  58         { .name = "TRACE_DEBUG", .value = LTTNG_LOGLEVEL_DEBUG },
  59 };
  60
  61 static const struct loglevel_name_value loglevel_log4j_values[] = {
  62         { .name = "OFF", .value = LTTNG_LOGLEVEL_LOG4J_OFF },
  63         { .name = "LOG4J_OFF", .value = LTTNG_LOGLEVEL_LOG4J_OFF },
  64         { .name = "FATAL", .value = LTTNG_LOGLEVEL_LOG4J_FATAL },
  65         { .name = "LOG4J_FATAL", .value = LTTNG_LOGLEVEL_LOG4J_FATAL },
  66         { .name = "ERROR", .value = LTTNG_LOGLEVEL_LOG4J_ERROR },
  67         { .name = "LOG4J_ERROR", .value = LTTNG_LOGLEVEL_LOG4J_ERROR },
  68         { .name = "WARN", .value = LTTNG_LOGLEVEL_LOG4J_WARN },
  69         { .name = "LOG4J_WARN", .value = LTTNG_LOGLEVEL_LOG4J_WARN },
  70         { .name = "INFO", .value = LTTNG_LOGLEVEL_LOG4J_INFO },
  71         { .name = "LOG4J_INFO", .value = LTTNG_LOGLEVEL_LOG4J_INFO },
  72         { .name = "DEBUG", .value = LTTNG_LOGLEVEL_LOG4J_DEBUG },
  73         { .name = "LOG4J_DEBUG", .value = LTTNG_LOGLEVEL_LOG4J_DEBUG },
  74         { .name = "TRACE", .value = LTTNG_LOGLEVEL_LOG4J_TRACE },
  75         { .name = "LOG4J_TRACE", .value = LTTNG_LOGLEVEL_LOG4J_TRACE },
  76         { .name = "ALL", .value = LTTNG_LOGLEVEL_LOG4J_ALL },
  77         { .name = "LOG4J_ALL", .value = LTTNG_LOGLEVEL_LOG4J_ALL },
  78 };
  79
  80 static const struct loglevel_name_value loglevel_jul_values[] = {
  81         { .name = "OFF", .value = LTTNG_LOGLEVEL_JUL_OFF },
  82         { .name = "JUL_OFF", .value = LTTNG_LOGLEVEL_JUL_OFF },
  83         { .name = "SEVERE", .value = LTTNG_LOGLEVEL_JUL_SEVERE },
  84         { .name = "JUL_SEVERE", .value = LTTNG_LOGLEVEL_JUL_SEVERE },
  85         { .name = "WARNING", .value = LTTNG_LOGLEVEL_JUL_WARNING },
  86         { .name = "JUL_WARNING", .value = LTTNG_LOGLEVEL_JUL_WARNING },
  87         { .name = "INFO", .value = LTTNG_LOGLEVEL_JUL_INFO },
  88         { .name = "JUL_INFO", .value = LTTNG_LOGLEVEL_JUL_INFO },
  89         { .name = "CONFIG", .value = LTTNG_LOGLEVEL_JUL_CONFIG },
  90         { .name = "JUL_CONFIG", .value = LTTNG_LOGLEVEL_JUL_CONFIG },
  91         { .name = "FINE", .value = LTTNG_LOGLEVEL_JUL_FINE },
  92         { .name = "JUL_FINE", .value = LTTNG_LOGLEVEL_JUL_FINE },
  93         { .name = "FINER", .value = LTTNG_LOGLEVEL_JUL_FINER },
  94         { .name = "JUL_FINER", .value = LTTNG_LOGLEVEL_JUL_FINER },
  95         { .name = "FINEST", .value = LTTNG_LOGLEVEL_JUL_FINEST },
  96         { .name = "JUL_FINEST", .value = LTTNG_LOGLEVEL_JUL_FINEST },
  97         { .name = "ALL", .value = LTTNG_LOGLEVEL_JUL_ALL },
  98         { .name = "JUL_ALL", .value = LTTNG_LOGLEVEL_JUL_ALL },
  99 };
 100
 101 static const struct loglevel_name_value loglevel_python_values[] = {
 102         { .name = "CRITICAL", .value = LTTNG_LOGLEVEL_PYTHON_CRITICAL },
 103         { .name = "PYTHON_CRITICAL", .value = LTTNG_LOGLEVEL_PYTHON_CRITICAL },
 104         { .name = "ERROR", .value = LTTNG_LOGLEVEL_PYTHON_ERROR },
 105         { .name = "PYTHON_ERROR", .value = LTTNG_LOGLEVEL_PYTHON_ERROR },
 106         { .name = "WARNING", .value = LTTNG_LOGLEVEL_PYTHON_WARNING },
 107         { .name = "PYTHON_WARNING", .value = LTTNG_LOGLEVEL_PYTHON_WARNING },
 108         { .name = "INFO", .value = LTTNG_LOGLEVEL_PYTHON_INFO },
 109         { .name = "PYTHON_INFO", .value = LTTNG_LOGLEVEL_PYTHON_INFO },
 110         { .name = "DEBUG", .value = LTTNG_LOGLEVEL_PYTHON_DEBUG },
 111         { .name = "PYTNON_DEBUG", .value = LTTNG_LOGLEVEL_PYTHON_DEBUG },
 112         { .name = "NOTSET", .value = LTTNG_LOGLEVEL_PYTHON_NOTSET },
 113         { .name = "PYTHON_NOTSET", .value = LTTNG_LOGLEVEL_PYTHON_NOTSET },
 114 };
 115
 116 static bool string_equal_insensitive(const char *a, const char *b)
 117 {
 118         return strcasecmp(a, b) == 0;
 119 }
 120
 121 static int lookup_value_from_name(const struct loglevel_name_value values[],
 122                                   size_t values_count,
 123                                   const char *name)
 124 {
 125         size_t i;
 126         int ret = -1;
 127
 128         if (!name) {
 129                 goto end;
 130         }
 131
 132         for (i = 0; i < values_count; i++) {
 133                 if (string_equal_insensitive(values[i].name, name)) {
 134                         /* Match found. */
 135                         ret = values[i].value;
 136                         goto end;
 137                 }
 138         }
 139
 140 end:
 141         return ret;
 142 }
 143
 144 static bool loglevel_parse_range_string_common(const char *str,
 145                                                const struct loglevel_name_value *nvs,
 146                                                size_t nvs_count,
 147                                                int *min,
 148                                                int *max)
 149 {
 150         bool ret;
 151         int i;
 152         const struct loglevel_name_value *nv;
 153
 154         for (i = 0; i < nvs_count; i++) {
 155                 nv = &nvs[i];
 156
 157                 if (strncmp(str, nv->name, strlen(nv->name)) == 0) {
 158                         break;
 159                 }
 160         }
 161
 162         if (i == nvs_count) {
 163                 goto error;
 164         }
 165
 166         *min = nv->value;
 167         str += strlen(nv->name);
 168
 169         if (*str == '\0') {
 170                 *max = nv->value;
 171                 ret = true;
 172                 goto end;
 173         }
 174
 175         if (strncmp(str, "..", strlen("..")) != 0) {
 176                 goto error;
 177         }
 178
 179         str += strlen("..");
 180
 181         if (*str == '\0') {
 182                 *max = LTTNG_LOGLEVEL_EMERG;
 183                 ret = true;
 184                 goto end;
 185         }
 186
 187         for (i = 0; i < nvs_count; i++) {
 188                 nv = &nvs[i];
 189
 190                 if (strcmp(str, nv->name) == 0) {
 191                         break;
 192                 }
 193         }
 194
 195         if (i == nvs_count) {
 196                 goto error;
 197         }
 198
 199         *max = nv->value;
 200
 201         ret = true;
 202         goto end;
 203
 204 error:
 205         ret = false;
 206
 207 end:
 208         return ret;
 209 }
 210
 211 int loglevel_name_to_value(const char *name, enum lttng_loglevel *loglevel)
 212 {
 213         int ret = lookup_value_from_name(loglevel_values, ARRAY_SIZE(loglevel_values), name);
 214
 215         if (ret >= 0) {
 216                 *loglevel = (typeof(*loglevel)) ret;
 217                 ret = 0;
 218         }
 219
 220         return ret;
 221 }
 222
 223 bool loglevel_parse_range_string(const char *str,
 224                                  enum lttng_loglevel *min,
 225                                  enum lttng_loglevel *max)
 226 {
 227         int min_int, max_int;
 228         bool ret = loglevel_parse_range_string_common(
 229                 str, loglevel_values, ARRAY_SIZE(loglevel_values), &min_int, &max_int);
 230
 231         *min = (lttng_loglevel) min_int;
 232         *max = (lttng_loglevel) max_int;
 233
 234         return ret;
 235 }
 236
 237 int loglevel_log4j_name_to_value(const char *name, enum lttng_loglevel_log4j *loglevel)
 238 {
 239         int ret = lookup_value_from_name(
 240                 loglevel_log4j_values, ARRAY_SIZE(loglevel_log4j_values), name);
 241
 242         if (ret >= 0) {
 243                 *loglevel = (typeof(*loglevel)) ret;
 244                 ret = 0;
 245         }
 246
 247         return ret;
 248 }
 249
 250 bool loglevel_log4j_parse_range_string(const char *str,
 251                                        enum lttng_loglevel_log4j *min,
 252                                        enum lttng_loglevel_log4j *max)
 253 {
 254         int min_int, max_int;
 255         bool ret = loglevel_parse_range_string_common(
 256                 str, loglevel_log4j_values, ARRAY_SIZE(loglevel_log4j_values), &min_int, &max_int);
 257
 258         *min = (lttng_loglevel_log4j) min_int;
 259         *max = (lttng_loglevel_log4j) max_int;
 260
 261         return ret;
 262 }
 263
 264 int loglevel_jul_name_to_value(const char *name, enum lttng_loglevel_jul *loglevel)
 265 {
 266         int ret =
 267                 lookup_value_from_name(loglevel_jul_values, ARRAY_SIZE(loglevel_jul_values), name);
 268
 269         if (ret >= 0) {
 270                 *loglevel = (typeof(*loglevel)) ret;
 271                 ret = 0;
 272         }
 273
 274         return ret;
 275 }
 276
 277 bool loglevel_jul_parse_range_string(const char *str,
 278                                      enum lttng_loglevel_jul *min,
 279                                      enum lttng_loglevel_jul *max)
 280 {
 281         int min_int, max_int;
 282         bool ret = loglevel_parse_range_string_common(
 283                 str, loglevel_jul_values, ARRAY_SIZE(loglevel_jul_values), &min_int, &max_int);
 284
 285         *min = (lttng_loglevel_jul) min_int;
 286         *max = (lttng_loglevel_jul) max_int;
 287
 288         return ret;
 289 }
 290
 291 int loglevel_python_name_to_value(const char *name, enum lttng_loglevel_python *loglevel)
 292 {
 293         int ret = lookup_value_from_name(
 294                 loglevel_python_values, ARRAY_SIZE(loglevel_python_values), name);
 295
 296         if (ret >= 0) {
 297                 *loglevel = (typeof(*loglevel)) ret;
 298                 ret = 0;
 299         }
 300
 301         return ret;
 302 }
 303
 304 bool loglevel_python_parse_range_string(const char *str,
 305                                         enum lttng_loglevel_python *min,
 306                                         enum lttng_loglevel_python *max)
 307 {
 308         int min_int, max_int;
 309         bool ret = loglevel_parse_range_string_common(str,
 310                                                       loglevel_python_values,
 311                                                       ARRAY_SIZE(loglevel_python_values),
 312                                                       &min_int,
 313                                                       &max_int);
 314
 315         *min = (lttng_loglevel_python) min_int;
 316         *max = (lttng_loglevel_python) max_int;
 317
 318         return ret;
 319 }
 320
 321 static const char *
 322 lookup_name_from_value(const struct loglevel_name_value values[], size_t values_count, int loglevel)
 323 {
 324         size_t i;
 325         const char *name = nullptr;
 326
 327         for (i = 0; i < values_count; i++) {
 328                 if (values[i].value == loglevel) {
 329                         /* Match found. */
 330                         name = values[i].name;
 331                         goto end;
 332                 }
 333         }
 334
 335 end:
 336         return name;
 337 }
 338
 339 const char *loglevel_value_to_name(int loglevel)
 340 {
 341         return lookup_name_from_value(loglevel_values, ARRAY_SIZE(loglevel_values), loglevel);
 342 }
 343
 344 const char *loglevel_log4j_value_to_name(int loglevel)
 345 {
 346         return lookup_name_from_value(
 347                 loglevel_log4j_values, ARRAY_SIZE(loglevel_log4j_values), loglevel);
 348 }
 349
 350 const char *loglevel_jul_value_to_name(int loglevel)
 351 {
 352         return lookup_name_from_value(
 353                 loglevel_jul_values, ARRAY_SIZE(loglevel_jul_values), loglevel);
 354 }
 355
 356 const char *loglevel_python_value_to_name(int loglevel)
 357 {
 358         return lookup_name_from_value(
 359                 loglevel_python_values, ARRAY_SIZE(loglevel_python_values), loglevel);
 360 }