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 #include <string.h>
  10 #include <strings.h>
  11 #include <ctype.h>
  12
  13 namespace {
  14 struct loglevel_name_value {
  15         const char *name;
  16         int value;
  17 };
  18 } /* namespace */
  19
  20 static
  21 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
  62 const struct loglevel_name_value loglevel_log4j_values[] = {
  63         { .name = "OFF", .value = LTTNG_LOGLEVEL_LOG4J_OFF },
  64         { .name = "LOG4J_OFF", .value = LTTNG_LOGLEVEL_LOG4J_OFF },
  65         { .name = "FATAL", .value = LTTNG_LOGLEVEL_LOG4J_FATAL },
  66         { .name = "LOG4J_FATAL", .value = LTTNG_LOGLEVEL_LOG4J_FATAL },
  67         { .name = "ERROR", .value = LTTNG_LOGLEVEL_LOG4J_ERROR },
  68         { .name = "LOG4J_ERROR", .value = LTTNG_LOGLEVEL_LOG4J_ERROR },
  69         { .name = "WARN", .value = LTTNG_LOGLEVEL_LOG4J_WARN },
  70         { .name = "LOG4J_WARN", .value = LTTNG_LOGLEVEL_LOG4J_WARN },
  71         { .name = "INFO", .value = LTTNG_LOGLEVEL_LOG4J_INFO },
  72         { .name = "LOG4J_INFO", .value = LTTNG_LOGLEVEL_LOG4J_INFO },
  73         { .name = "DEBUG", .value = LTTNG_LOGLEVEL_LOG4J_DEBUG },
  74         { .name = "LOG4J_DEBUG", .value = LTTNG_LOGLEVEL_LOG4J_DEBUG },
  75         { .name = "TRACE", .value = LTTNG_LOGLEVEL_LOG4J_TRACE },
  76         { .name = "LOG4J_TRACE", .value = LTTNG_LOGLEVEL_LOG4J_TRACE },
  77         { .name = "ALL", .value = LTTNG_LOGLEVEL_LOG4J_ALL },
  78         { .name = "LOG4J_ALL", .value = LTTNG_LOGLEVEL_LOG4J_ALL },
  79 };
  80
  81 static
  82 const struct loglevel_name_value loglevel_jul_values[] = {
  83         { .name = "OFF", .value = LTTNG_LOGLEVEL_JUL_OFF },
  84         { .name = "JUL_OFF", .value = LTTNG_LOGLEVEL_JUL_OFF },
  85         { .name = "SEVERE", .value = LTTNG_LOGLEVEL_JUL_SEVERE },
  86         { .name = "JUL_SEVERE", .value = LTTNG_LOGLEVEL_JUL_SEVERE },
  87         { .name = "WARNING", .value = LTTNG_LOGLEVEL_JUL_WARNING },
  88         { .name = "JUL_WARNING", .value = LTTNG_LOGLEVEL_JUL_WARNING },
  89         { .name = "INFO", .value = LTTNG_LOGLEVEL_JUL_INFO },
  90         { .name = "JUL_INFO", .value = LTTNG_LOGLEVEL_JUL_INFO },
  91         { .name = "CONFIG", .value = LTTNG_LOGLEVEL_JUL_CONFIG },
  92         { .name = "JUL_CONFIG", .value = LTTNG_LOGLEVEL_JUL_CONFIG },
  93         { .name = "FINE", .value = LTTNG_LOGLEVEL_JUL_FINE },
  94         { .name = "JUL_FINE", .value = LTTNG_LOGLEVEL_JUL_FINE },
  95         { .name = "FINER", .value = LTTNG_LOGLEVEL_JUL_FINER },
  96         { .name = "JUL_FINER", .value = LTTNG_LOGLEVEL_JUL_FINER },
  97         { .name = "FINEST", .value = LTTNG_LOGLEVEL_JUL_FINEST },
  98         { .name = "JUL_FINEST", .value = LTTNG_LOGLEVEL_JUL_FINEST },
  99         { .name = "ALL", .value = LTTNG_LOGLEVEL_JUL_ALL },
 100         { .name = "JUL_ALL", .value = LTTNG_LOGLEVEL_JUL_ALL },
 101 };
 102
 103 static
 104 const struct loglevel_name_value loglevel_python_values[] = {
 105         { .name = "CRITICAL", .value = LTTNG_LOGLEVEL_PYTHON_CRITICAL },
 106         { .name = "PYTHON_CRITICAL", .value = LTTNG_LOGLEVEL_PYTHON_CRITICAL },
 107         { .name = "ERROR", .value = LTTNG_LOGLEVEL_PYTHON_ERROR },
 108         { .name = "PYTHON_ERROR", .value = LTTNG_LOGLEVEL_PYTHON_ERROR },
 109         { .name = "WARNING", .value = LTTNG_LOGLEVEL_PYTHON_WARNING },
 110         { .name = "PYTHON_WARNING", .value = LTTNG_LOGLEVEL_PYTHON_WARNING },
 111         { .name = "INFO", .value = LTTNG_LOGLEVEL_PYTHON_INFO },
 112         { .name = "PYTHON_INFO", .value = LTTNG_LOGLEVEL_PYTHON_INFO },
 113         { .name = "DEBUG", .value = LTTNG_LOGLEVEL_PYTHON_DEBUG },
 114         { .name = "PYTNON_DEBUG", .value = LTTNG_LOGLEVEL_PYTHON_DEBUG },
 115         { .name = "NOTSET", .value = LTTNG_LOGLEVEL_PYTHON_NOTSET },
 116         { .name = "PYTHON_NOTSET", .value = LTTNG_LOGLEVEL_PYTHON_NOTSET },
 117 };
 118
 119 static
 120 bool string_equal_insensitive(const char *a, const char *b)
 121 {
 122         return strcasecmp(a, b) == 0;
 123 }
 124
 125 static
 126 int lookup_value_from_name(const struct loglevel_name_value values[],
 127                 size_t values_count, const char *name)
 128 {
 129         size_t i;
 130         int ret = -1;
 131
 132         if (!name) {
 133                 goto end;
 134         }
 135
 136         for (i = 0; i < values_count; i++) {
 137                 if (string_equal_insensitive(values[i].name, name)) {
 138                         /* Match found. */
 139                         ret = values[i].value;
 140                         goto end;
 141                 }
 142         }
 143
 144 end:
 145         return ret;
 146 }
 147
 148 static bool loglevel_parse_range_string_common(const char *str,
 149                 const struct loglevel_name_value *nvs,
 150                 size_t nvs_count,
 151                 int *min,
 152                 int *max)
 153 {
 154         bool ret;
 155         int i;
 156         const struct loglevel_name_value *nv;
 157
 158         for (i = 0; i < nvs_count; i++) {
 159                 nv = &nvs[i];
 160
 161                 if (strncmp(str, nv->name, strlen(nv->name)) == 0) {
 162                         break;
 163                 }
 164         }
 165
 166         if (i == nvs_count) {
 167                 goto error;
 168         }
 169
 170         *min = nv->value;
 171         str += strlen(nv->name);
 172
 173         if (*str == '\0') {
 174                 *max = nv->value;
 175                 ret = true;
 176                 goto end;
 177         }
 178
 179         if (strncmp(str, "..", strlen("..")) != 0) {
 180                 goto error;
 181         }
 182
 183         str += strlen("..");
 184
 185         if (*str == '\0') {
 186                 *max = LTTNG_LOGLEVEL_EMERG;
 187                 ret = true;
 188                 goto end;
 189         }
 190
 191         for (i = 0; i < nvs_count; i++) {
 192                 nv = &nvs[i];
 193
 194                 if (strcmp(str, nv->name) == 0) {
 195                         break;
 196                 }
 197         }
 198
 199         if (i == nvs_count) {
 200                 goto error;
 201         }
 202
 203         *max = nv->value;
 204
 205         ret = true;
 206         goto end;
 207
 208 error:
 209         ret = false;
 210
 211 end:
 212         return ret;
 213 }
 214
 215 int loglevel_name_to_value(const char *name, enum lttng_loglevel *loglevel)
 216 {
 217         int ret = lookup_value_from_name(loglevel_values,
 218                         ARRAY_SIZE(loglevel_values), name);
 219
 220         if (ret >= 0) {
 221                 *loglevel = (typeof(*loglevel)) ret;
 222                 ret = 0;
 223         }
 224
 225         return ret;
 226 }
 227
 228 bool loglevel_parse_range_string(const char *str,
 229                 enum lttng_loglevel *min,
 230                 enum lttng_loglevel *max)
 231 {
 232         int min_int, max_int;
 233         bool ret = loglevel_parse_range_string_common(str, loglevel_values,
 234                         ARRAY_SIZE(loglevel_values), &min_int, &max_int);
 235
 236         *min = (lttng_loglevel) min_int;
 237         *max = (lttng_loglevel) max_int;
 238
 239         return ret;
 240 }
 241
 242 int loglevel_log4j_name_to_value(
 243                 const char *name, enum lttng_loglevel_log4j *loglevel)
 244 {
 245         int ret = lookup_value_from_name(loglevel_log4j_values,
 246                         ARRAY_SIZE(loglevel_log4j_values),
 247                         name);
 248
 249         if (ret >= 0) {
 250                 *loglevel = (typeof(*loglevel)) ret;
 251                 ret = 0;
 252         }
 253
 254         return ret;
 255 }
 256
 257 bool loglevel_log4j_parse_range_string(const char *str,
 258                 enum lttng_loglevel_log4j *min,
 259                 enum lttng_loglevel_log4j *max)
 260 {
 261         int min_int, max_int;
 262         bool ret = loglevel_parse_range_string_common(str,
 263                         loglevel_log4j_values,
 264                         ARRAY_SIZE(loglevel_log4j_values), &min_int, &max_int);
 265
 266         *min = (lttng_loglevel_log4j) min_int;
 267         *max = (lttng_loglevel_log4j) max_int;
 268
 269         return ret;
 270 }
 271
 272 int loglevel_jul_name_to_value(
 273                 const char *name, enum lttng_loglevel_jul *loglevel)
 274 {
 275         int ret = lookup_value_from_name(loglevel_jul_values,
 276                         ARRAY_SIZE(loglevel_jul_values),
 277                         name);
 278
 279         if (ret >= 0) {
 280                 *loglevel = (typeof(*loglevel)) ret;
 281                 ret = 0;
 282         }
 283
 284         return ret;
 285 }
 286
 287 bool loglevel_jul_parse_range_string(const char *str,
 288                 enum lttng_loglevel_jul *min,
 289                 enum lttng_loglevel_jul *max)
 290 {
 291         int min_int, max_int;
 292         bool ret = loglevel_parse_range_string_common(str, loglevel_jul_values,
 293                         ARRAY_SIZE(loglevel_jul_values), &min_int, &max_int);
 294
 295         *min = (lttng_loglevel_jul) min_int;
 296         *max = (lttng_loglevel_jul) max_int;
 297
 298         return ret;
 299 }
 300
 301 int loglevel_python_name_to_value(
 302                 const char *name, enum lttng_loglevel_python *loglevel)
 303 {
 304         int ret = lookup_value_from_name(loglevel_python_values,
 305                         ARRAY_SIZE(loglevel_python_values),
 306                         name);
 307
 308         if (ret >= 0) {
 309                 *loglevel = (typeof(*loglevel)) ret;
 310                 ret = 0;
 311         }
 312
 313         return ret;
 314 }
 315
 316 bool loglevel_python_parse_range_string(const char *str,
 317                 enum lttng_loglevel_python *min,
 318                 enum lttng_loglevel_python *max)
 319 {
 320         int min_int, max_int;
 321         bool ret = loglevel_parse_range_string_common(str,
 322                         loglevel_python_values,
 323                         ARRAY_SIZE(loglevel_python_values), &min_int, &max_int);
 324
 325         *min = (lttng_loglevel_python) min_int;
 326         *max = (lttng_loglevel_python) max_int;
 327
 328         return ret;
 329 }
 330
 331 static
 332 const char *lookup_name_from_value(const struct loglevel_name_value values[],
 333                 size_t values_count, int loglevel)
 334 {
 335         size_t i;
 336         const char *name = NULL;
 337
 338         for (i = 0; i < values_count; i++) {
 339                 if (values[i].value == loglevel) {
 340                         /* Match found. */
 341                         name = values[i].name;
 342                         goto end;
 343                 }
 344         }
 345
 346 end:
 347         return name;
 348 }
 349
 350 const char *loglevel_value_to_name(int loglevel)
 351 {
 352         return lookup_name_from_value(
 353                         loglevel_values, ARRAY_SIZE(loglevel_values), loglevel);
 354 }
 355
 356 const char *loglevel_log4j_value_to_name(int loglevel)
 357 {
 358         return lookup_name_from_value(loglevel_log4j_values,
 359                         ARRAY_SIZE(loglevel_log4j_values), loglevel);
 360 }
 361
 362 const char *loglevel_jul_value_to_name(int loglevel)
 363 {
 364         return lookup_name_from_value(loglevel_jul_values,
 365                         ARRAY_SIZE(loglevel_jul_values), loglevel);
 366 }
 367
 368 const char *loglevel_python_value_to_name(int loglevel)
 369 {
 370         return lookup_name_from_value(loglevel_python_values,
 371                         ARRAY_SIZE(loglevel_python_values), loglevel);
 372 }