src/bin/lttng/commands/enable_events.cpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <common/compat/getenv.hpp>
  10 #include <common/compat/string.hpp>
  11 #include <common/make-unique-wrapper.hpp>
  12 #include <common/scope-exit.hpp>
  13 #include <common/sessiond-comm/sessiond-comm.hpp>
  14 #include <common/string-utils/string-utils.hpp>
  15 #include <common/utils.hpp>
  16
  17 #include <ctype.h>
  18 #include <inttypes.h>
  19 #include <popt.h>
  20 #include <sstream>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string>
  24 #include <sys/stat.h>
  25 #include <sys/types.h>
  26 #include <unistd.h>
  27 #include <vector>
  28
  29 /* Mi dependancy */
  30 #include "../command.hpp"
  31 #include "../loglevel.hpp"
  32 #include "../uprobe.hpp"
  33
  34 #include <common/mi-lttng.hpp>
  35
  36 #include <lttng/domain-internal.hpp>
  37 #include <lttng/event-internal.hpp>
  38
  39 #if (LTTNG_SYMBOL_NAME_LEN == 256)
  40 #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
  41 #endif
  42
  43 namespace {
  44 void _mi_lttng_writer_deleter_func(mi_writer *writer)
  45 {
  46         if (writer && mi_lttng_writer_destroy(writer)) {
  47                 LTTNG_THROW_ERROR("Failed to destroy mi_writer instance");
  48         }
  49 }
  50
  51 using mi_writer_uptr = std::unique_ptr<
  52         mi_writer,
  53         lttng::memory::create_deleter_class<mi_writer, _mi_lttng_writer_deleter_func>::deleter>;
  54 using event_rule_patterns = std::vector<std::string>;
  55
  56 int opt_event_type;
  57 const char *opt_loglevel;
  58 int opt_loglevel_type;
  59 int opt_kernel;
  60 char *opt_session_name;
  61 int opt_userspace;
  62 int opt_jul;
  63 int opt_log4j;
  64 int opt_python;
  65 int opt_enable_all;
  66 char *opt_probe;
  67 char *opt_userspace_probe;
  68 char *opt_function;
  69 char *opt_channel_name;
  70 char *opt_filter;
  71 char *opt_exclude;
  72
  73 struct lttng_handle *handle;
  74 mi_writer_uptr writer;
  75
  76 #ifdef LTTNG_EMBED_HELP
  77 static const char help_msg[] =
  78 #include <lttng-enable-event.1.h>
  79         ;
  80 #endif
  81
  82 enum {
  83         OPT_HELP = 1,
  84         OPT_TRACEPOINT,
  85         OPT_PROBE,
  86         OPT_USERSPACE_PROBE,
  87         OPT_FUNCTION,
  88         OPT_SYSCALL,
  89         OPT_USERSPACE,
  90         OPT_LOGLEVEL,
  91         OPT_LOGLEVEL_ONLY,
  92         OPT_LIST_OPTIONS,
  93         OPT_FILTER,
  94         OPT_EXCLUDE,
  95 };
  96
  97 struct poptOption long_options[] = {
  98         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
  99         { "help", 'h', POPT_ARG_NONE, nullptr, OPT_HELP, nullptr, nullptr },
 100         { "session", 's', POPT_ARG_STRING, &opt_session_name, 0, nullptr, nullptr },
 101         { "all", 'a', POPT_ARG_VAL, &opt_enable_all, 1, nullptr, nullptr },
 102         { "channel", 'c', POPT_ARG_STRING, &opt_channel_name, 0, nullptr, nullptr },
 103         { "kernel", 'k', POPT_ARG_VAL, &opt_kernel, 1, nullptr, nullptr },
 104         { "userspace", 'u', POPT_ARG_NONE, nullptr, OPT_USERSPACE, nullptr, nullptr },
 105         { "jul", 'j', POPT_ARG_VAL, &opt_jul, 1, nullptr, nullptr },
 106         { "log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, nullptr, nullptr },
 107         { "python", 'p', POPT_ARG_VAL, &opt_python, 1, nullptr, nullptr },
 108         { "tracepoint", 0, POPT_ARG_NONE, nullptr, OPT_TRACEPOINT, nullptr, nullptr },
 109         { "probe", 0, POPT_ARG_STRING, &opt_probe, OPT_PROBE, nullptr, nullptr },
 110         { "userspace-probe",
 111           0,
 112           POPT_ARG_STRING,
 113           &opt_userspace_probe,
 114           OPT_USERSPACE_PROBE,
 115           nullptr,
 116           nullptr },
 117         { "function", 0, POPT_ARG_STRING, &opt_function, OPT_FUNCTION, nullptr, nullptr },
 118         { "syscall", 0, POPT_ARG_NONE, nullptr, OPT_SYSCALL, nullptr, nullptr },
 119         { "loglevel", 0, POPT_ARG_STRING, nullptr, OPT_LOGLEVEL, nullptr, nullptr },
 120         { "loglevel-only", 0, POPT_ARG_STRING, nullptr, OPT_LOGLEVEL_ONLY, nullptr, nullptr },
 121         { "list-options", 0, POPT_ARG_NONE, nullptr, OPT_LIST_OPTIONS, nullptr, nullptr },
 122         { "filter", 'f', POPT_ARG_STRING, &opt_filter, OPT_FILTER, nullptr, nullptr },
 123         { "exclude", 'x', POPT_ARG_STRING, &opt_exclude, OPT_EXCLUDE, nullptr, nullptr },
 124         { nullptr, 0, 0, nullptr, 0, nullptr, nullptr }
 125 };
 126
 127 /*
 128  * Parse probe options.
 129  */
 130 int parse_probe_opts(struct lttng_event *ev, char *opt)
 131 {
 132         int ret = CMD_SUCCESS;
 133         int match;
 134         char s_hex[19];
 135 #define S_HEX_LEN_SCANF_IS_A_BROKEN_API "18" /* 18 is (19 - 1) (\0 is extra) */
 136         char name[LTTNG_SYMBOL_NAME_LEN];
 137
 138         if (opt == nullptr) {
 139                 ret = CMD_ERROR;
 140                 goto end;
 141         }
 142
 143         /* Check for symbol+offset */
 144         match = sscanf(opt,
 145                        "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
 146                        "[^'+']+%" S_HEX_LEN_SCANF_IS_A_BROKEN_API "s",
 147                        name,
 148                        s_hex);
 149         if (match == 2) {
 150                 strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
 151                 ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 152                 DBG("probe symbol %s", ev->attr.probe.symbol_name);
 153                 if (*s_hex == '\0') {
 154                         ERR("Invalid probe offset %s", s_hex);
 155                         ret = CMD_ERROR;
 156                         goto end;
 157                 }
 158                 ev->attr.probe.offset = strtoull(s_hex, nullptr, 0);
 159                 DBG("probe offset %" PRIu64, ev->attr.probe.offset);
 160                 ev->attr.probe.addr = 0;
 161                 goto end;
 162         }
 163
 164         /* Check for symbol */
 165         if (isalpha(name[0]) || name[0] == '_') {
 166                 match = sscanf(opt, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "s", name);
 167                 if (match == 1) {
 168                         strncpy(ev->attr.probe.symbol_name, name, LTTNG_SYMBOL_NAME_LEN);
 169                         ev->attr.probe.symbol_name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 170                         DBG("probe symbol %s", ev->attr.probe.symbol_name);
 171                         ev->attr.probe.offset = 0;
 172                         DBG("probe offset %" PRIu64, ev->attr.probe.offset);
 173                         ev->attr.probe.addr = 0;
 174                         goto end;
 175                 }
 176         }
 177
 178         /* Check for address */
 179         match = sscanf(opt, "%" S_HEX_LEN_SCANF_IS_A_BROKEN_API "s", s_hex);
 180         if (match > 0) {
 181                 /*
 182                  * Return an error if the first character of the tentative
 183                  * address is NULL or not a digit. It can be "0" if the address
 184                  * is in hexadecimal and can be 1 to 9 if it's in decimal.
 185                  */
 186                 if (*s_hex == '\0' || !isdigit(*s_hex)) {
 187                         ERR("Invalid probe description %s", s_hex);
 188                         ret = CMD_ERROR;
 189                         goto end;
 190                 }
 191                 ev->attr.probe.addr = strtoull(s_hex, nullptr, 0);
 192                 DBG("probe addr %" PRIu64, ev->attr.probe.addr);
 193                 ev->attr.probe.offset = 0;
 194                 memset(ev->attr.probe.symbol_name, 0, LTTNG_SYMBOL_NAME_LEN);
 195                 goto end;
 196         }
 197
 198         /* No match */
 199         ret = CMD_ERROR;
 200
 201 end:
 202         return ret;
 203 }
 204
 205 const char *print_channel_name(const char *name)
 206 {
 207         return name ?: DEFAULT_CHANNEL_NAME;
 208 }
 209
 210 const char *print_raw_channel_name(const char *name)
 211 {
 212         return name ?: "<default>";
 213 }
 214
 215 /*
 216  * Mi print exlcusion list
 217  */
 218 int mi_print_exclusion(const struct lttng_dynamic_pointer_array *exclusions)
 219 {
 220         int ret;
 221         size_t i;
 222         const size_t count = lttng_dynamic_pointer_array_get_count(exclusions);
 223
 224         LTTNG_ASSERT(writer);
 225
 226         if (count == 0) {
 227                 ret = 0;
 228                 goto end;
 229         }
 230
 231         ret = mi_lttng_writer_open_element(writer.get(), config_element_exclusions);
 232         if (ret) {
 233                 goto end;
 234         }
 235
 236         for (i = 0; i < count; i++) {
 237                 const char *exclusion =
 238                         (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
 239
 240                 ret = mi_lttng_writer_write_element_string(
 241                         writer.get(), config_element_exclusion, exclusion);
 242                 if (ret) {
 243                         goto end;
 244                 }
 245         }
 246
 247         /* Close exclusions element */
 248         ret = mi_lttng_writer_close_element(writer.get());
 249
 250 end:
 251         return ret;
 252 }
 253
 254 /*
 255  * Return allocated string for pretty-printing exclusion names.
 256  */
 257 char *print_exclusions(const struct lttng_dynamic_pointer_array *exclusions)
 258 {
 259         int length = 0;
 260         size_t i;
 261         const char preamble[] = " excluding ";
 262         char *ret;
 263         const size_t count = lttng_dynamic_pointer_array_get_count(exclusions);
 264
 265         if (count == 0) {
 266                 return strdup("");
 267         }
 268
 269         /* Calculate total required length. */
 270         for (i = 0; i < count; i++) {
 271                 const char *exclusion =
 272                         (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
 273
 274                 length += strlen(exclusion) + 4;
 275         }
 276
 277         length += sizeof(preamble);
 278         ret = calloc<char>(length);
 279         if (!ret) {
 280                 return nullptr;
 281         }
 282
 283         strncpy(ret, preamble, length);
 284         for (i = 0; i < count; i++) {
 285                 const char *exclusion =
 286                         (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
 287
 288                 strcat(ret, "\"");
 289                 strcat(ret, exclusion);
 290                 strcat(ret, "\"");
 291                 if (i != count - 1) {
 292                         strcat(ret, ", ");
 293                 }
 294         }
 295
 296         return ret;
 297 }
 298
 299 int check_exclusion_subsets(const char *pattern, const char *exclusion)
 300 {
 301         bool warn = false;
 302         int ret = 0;
 303         const char *e = pattern;
 304         const char *x = exclusion;
 305
 306         /* Scan both the excluder and the event letter by letter */
 307         while (true) {
 308                 if (*e == '\\') {
 309                         if (*x != *e) {
 310                                 warn = true;
 311                                 goto end;
 312                         }
 313
 314                         e++;
 315                         x++;
 316                         goto cmp_chars;
 317                 }
 318
 319                 if (*x == '*') {
 320                         /* Event is a subset of the excluder */
 321                         ERR("Event %s: %s excludes all events from %s", pattern, exclusion, pattern);
 322                         goto error;
 323                 }
 324
 325                 if (*e == '*') {
 326                         /*
 327                          * Reached the end of the event name before the
 328                          * end of the exclusion: this is valid.
 329                          */
 330                         goto end;
 331                 }
 332
 333         cmp_chars:
 334                 if (*x != *e) {
 335                         warn = true;
 336                         break;
 337                 }
 338
 339                 x++;
 340                 e++;
 341         }
 342
 343         goto end;
 344
 345 error:
 346         ret = -1;
 347
 348 end:
 349         if (warn) {
 350                 WARN("Event %s: %s does not exclude any events from %s",
 351                      pattern,
 352                      exclusion,
 353                      pattern);
 354         }
 355
 356         return ret;
 357 }
 358
 359 int create_exclusion_list_and_validate(const char *pattern,
 360                                        const char *exclusions_arg,
 361                                        struct lttng_dynamic_pointer_array *exclusions)
 362 {
 363         int ret = 0;
 364
 365         /* Split exclusions. */
 366         ret = strutils_split(exclusions_arg, ',', true, exclusions);
 367         if (ret < 0) {
 368                 goto error;
 369         }
 370
 371         if (validate_exclusion_list(pattern, exclusions) != 0) {
 372                 goto error;
 373         }
 374
 375         goto end;
 376
 377 error:
 378         ret = -1;
 379         lttng_dynamic_pointer_array_reset(exclusions);
 380
 381 end:
 382         return ret;
 383 }
 384
 385 void warn_on_truncated_exclusion_names(const struct lttng_dynamic_pointer_array *exclusions,
 386                                        int *warn)
 387 {
 388         size_t i;
 389         const size_t num_exclusions = lttng_dynamic_pointer_array_get_count(exclusions);
 390
 391         for (i = 0; i < num_exclusions; i++) {
 392                 const char *const exclusion =
 393                         (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions, i);
 394
 395                 if (strlen(exclusion) >= LTTNG_SYMBOL_NAME_LEN) {
 396                         WARN("Event exclusion \"%s\" will be truncated", exclusion);
 397                         *warn = 1;
 398                 }
 399         }
 400 }
 401
 402 /*
 403  * Enabling event using the lttng API.
 404  * Note: in case of error only the last error code will be return.
 405  */
 406 int enable_events(const std::string& session_name, const event_rule_patterns& patterns)
 407 {
 408         int ret = CMD_SUCCESS, command_ret = CMD_SUCCESS;
 409         int error_holder = CMD_SUCCESS, warn = 0, error = 0, success = 1;
 410         char *channel_name = nullptr;
 411         struct lttng_event *ev;
 412         struct lttng_domain dom = {};
 413         struct lttng_dynamic_pointer_array exclusions;
 414         struct lttng_userspace_probe_location *uprobe_loc = nullptr;
 415
 416         lttng_dynamic_pointer_array_init(&exclusions, nullptr);
 417
 418         ev = lttng_event_create();
 419         if (!ev) {
 420                 ret = CMD_ERROR;
 421                 goto error;
 422         }
 423
 424         if (opt_kernel) {
 425                 if (opt_loglevel) {
 426                         WARN("Kernel loglevels are not supported.");
 427                 }
 428         }
 429
 430         /* Create lttng domain */
 431         if (opt_kernel) {
 432                 dom.type = LTTNG_DOMAIN_KERNEL;
 433                 dom.buf_type = LTTNG_BUFFER_GLOBAL;
 434         } else if (opt_userspace) {
 435                 dom.type = LTTNG_DOMAIN_UST;
 436                 /* Default. */
 437                 dom.buf_type = LTTNG_BUFFER_PER_UID;
 438         } else if (opt_jul) {
 439                 dom.type = LTTNG_DOMAIN_JUL;
 440                 /* Default. */
 441                 dom.buf_type = LTTNG_BUFFER_PER_UID;
 442         } else if (opt_log4j) {
 443                 dom.type = LTTNG_DOMAIN_LOG4J;
 444                 /* Default. */
 445                 dom.buf_type = LTTNG_BUFFER_PER_UID;
 446         } else if (opt_python) {
 447                 dom.type = LTTNG_DOMAIN_PYTHON;
 448                 /* Default. */
 449                 dom.buf_type = LTTNG_BUFFER_PER_UID;
 450         } else {
 451                 /* Checked by the caller. */
 452                 abort();
 453         }
 454
 455         if (opt_exclude) {
 456                 switch (dom.type) {
 457                 case LTTNG_DOMAIN_KERNEL:
 458                 case LTTNG_DOMAIN_JUL:
 459                 case LTTNG_DOMAIN_LOG4J:
 460                 case LTTNG_DOMAIN_PYTHON:
 461                         ERR("Event name exclusions are not yet implemented for %s events",
 462                             lttng_domain_type_str(dom.type));
 463                         ret = CMD_ERROR;
 464                         goto error;
 465                 case LTTNG_DOMAIN_UST:
 466                         /* Exclusions supported */
 467                         break;
 468                 default:
 469                         abort();
 470                 }
 471         }
 472
 473         /*
 474          * Adding a filter to a probe, function or userspace-probe would be
 475          * denied by the kernel tracer as it's not supported at the moment. We
 476          * do an early check here to warn the user.
 477          */
 478         if (opt_filter && opt_kernel) {
 479                 switch (opt_event_type) {
 480                 case LTTNG_EVENT_ALL:
 481                 case LTTNG_EVENT_TRACEPOINT:
 482                 case LTTNG_EVENT_SYSCALL:
 483                         break;
 484                 case LTTNG_EVENT_PROBE:
 485                 case LTTNG_EVENT_USERSPACE_PROBE:
 486                 case LTTNG_EVENT_FUNCTION:
 487                         ERR("Filter expressions are not supported for %s events",
 488                             get_event_type_str((lttng_event_type) opt_event_type));
 489                         ret = CMD_ERROR;
 490                         goto error;
 491                 default:
 492                         ret = CMD_UNDEFINED;
 493                         goto error;
 494                 }
 495         }
 496
 497         channel_name = opt_channel_name;
 498
 499         handle = lttng_create_handle(session_name.c_str(), &dom);
 500         if (handle == nullptr) {
 501                 ret = -1;
 502                 goto error;
 503         }
 504
 505         /* Prepare Mi */
 506         if (lttng_opt_mi) {
 507                 /* Open a events element */
 508                 ret = mi_lttng_writer_open_element(writer.get(), config_element_events);
 509                 if (ret) {
 510                         ret = CMD_ERROR;
 511                         goto error;
 512                 }
 513         }
 514
 515         for (const auto& pattern : patterns) {
 516                 /* Copy name and type of the event */
 517                 strncpy(ev->name, pattern.c_str(), LTTNG_SYMBOL_NAME_LEN);
 518                 ev->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 519                 ev->type = (lttng_event_type) opt_event_type;
 520
 521                 /* Kernel tracer action */
 522                 if (opt_kernel) {
 523                         DBG_FMT("Enabling kernel event: pattern=`{}`, channel_name=`{}`",
 524                                 pattern,
 525                                 print_channel_name(channel_name));
 526
 527                         switch (opt_event_type) {
 528                         case LTTNG_EVENT_ALL: /* Enable tracepoints and syscalls */
 529                                 /* If event name differs from *, select tracepoint. */
 530                                 if (strcmp(ev->name, "*") != 0) {
 531                                         ev->type = LTTNG_EVENT_TRACEPOINT;
 532                                 }
 533                                 break;
 534                         case LTTNG_EVENT_TRACEPOINT:
 535                                 break;
 536                         case LTTNG_EVENT_PROBE:
 537                                 ret = parse_probe_opts(ev, opt_probe);
 538                                 if (ret) {
 539                                         ERR("Unable to parse probe options");
 540                                         ret = CMD_ERROR;
 541                                         goto error;
 542                                 }
 543                                 break;
 544                         case LTTNG_EVENT_USERSPACE_PROBE:
 545                                 LTTNG_ASSERT(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
 546
 547                                 ret = parse_userspace_probe_opts(opt_userspace_probe, &uprobe_loc);
 548                                 if (ret) {
 549                                         switch (ret) {
 550                                         case CMD_UNSUPPORTED:
 551                                                 /*
 552                                                  * Error message describing
 553                                                  * what is not supported was
 554                                                  * printed in the function.
 555                                                  */
 556                                                 break;
 557                                         case CMD_ERROR:
 558                                         default:
 559                                                 ERR("Unable to parse userspace probe options");
 560                                                 break;
 561                                         }
 562                                         goto error;
 563                                 }
 564
 565                                 ret = lttng_event_set_userspace_probe_location(ev, uprobe_loc);
 566                                 if (ret) {
 567                                         WARN("Failed to set probe location on event");
 568                                         ret = CMD_ERROR;
 569                                         goto error;
 570                                 }
 571
 572                                 /* Ownership of the uprobe location was transferred to the event. */
 573                                 uprobe_loc = nullptr;
 574                                 break;
 575                         case LTTNG_EVENT_FUNCTION:
 576                                 ret = parse_probe_opts(ev, opt_function);
 577                                 if (ret) {
 578                                         ERR("Unable to parse function probe options");
 579                                         ret = CMD_ERROR;
 580                                         goto error;
 581                                 }
 582                                 break;
 583                         case LTTNG_EVENT_SYSCALL:
 584                                 ev->type = LTTNG_EVENT_SYSCALL;
 585                                 break;
 586                         default:
 587                                 ret = CMD_UNDEFINED;
 588                                 goto error;
 589                         }
 590
 591                         /* kernel loglevels not implemented */
 592                         ev->loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
 593                 } else if (opt_userspace) { /* User-space tracer action */
 594                         DBG("Enabling UST event %s for channel %s, loglevel %s",
 595                             pattern.c_str(),
 596                             print_channel_name(channel_name),
 597                             opt_loglevel ?: "<all>");
 598
 599                         switch (opt_event_type) {
 600                         case LTTNG_EVENT_ALL: /* Default behavior is tracepoint */
 601                                 /* Fall-through */
 602                         case LTTNG_EVENT_TRACEPOINT:
 603                                 /* Copy name and type of the event */
 604                                 ev->type = LTTNG_EVENT_TRACEPOINT;
 605                                 strncpy(ev->name, pattern.c_str(), LTTNG_SYMBOL_NAME_LEN);
 606                                 ev->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 607                                 break;
 608                         case LTTNG_EVENT_PROBE:
 609                         case LTTNG_EVENT_FUNCTION:
 610                         case LTTNG_EVENT_SYSCALL:
 611                         case LTTNG_EVENT_USERSPACE_PROBE:
 612                         default:
 613                                 ERR("Event type not available for user-space tracing");
 614                                 ret = CMD_UNSUPPORTED;
 615                                 goto error;
 616                         }
 617
 618                         if (opt_exclude) {
 619                                 ev->exclusion = 1;
 620                                 if (opt_event_type != LTTNG_EVENT_ALL &&
 621                                     opt_event_type != LTTNG_EVENT_TRACEPOINT) {
 622                                         ERR("Exclusion option can only be used with tracepoint events");
 623                                         ret = CMD_ERROR;
 624                                         goto error;
 625                                 }
 626                                 /* Free previously allocated items. */
 627                                 lttng_dynamic_pointer_array_reset(&exclusions);
 628                                 ret = create_exclusion_list_and_validate(
 629                                         pattern.c_str(), opt_exclude, &exclusions);
 630                                 if (ret) {
 631                                         ret = CMD_ERROR;
 632                                         goto error;
 633                                 }
 634
 635                                 warn_on_truncated_exclusion_names(&exclusions, &warn);
 636                         }
 637
 638                         ev->loglevel_type = (lttng_loglevel_type) opt_loglevel_type;
 639                         if (opt_loglevel) {
 640                                 enum lttng_loglevel loglevel;
 641                                 const int name_search_ret =
 642                                         loglevel_name_to_value(opt_loglevel, &loglevel);
 643
 644                                 if (name_search_ret == -1) {
 645                                         ERR("Unknown loglevel %s", opt_loglevel);
 646                                         ret = -LTTNG_ERR_INVALID;
 647                                         goto error;
 648                                 }
 649
 650                                 ev->loglevel = (int) loglevel;
 651                         } else {
 652                                 ev->loglevel = -1;
 653                         }
 654                 } else if (opt_jul || opt_log4j || opt_python) {
 655                         if (opt_event_type != LTTNG_EVENT_ALL &&
 656                             opt_event_type != LTTNG_EVENT_TRACEPOINT) {
 657                                 ERR("Event type not supported for domain.");
 658                                 ret = CMD_UNSUPPORTED;
 659                                 goto error;
 660                         }
 661
 662                         ev->loglevel_type = (lttng_loglevel_type) opt_loglevel_type;
 663                         if (opt_loglevel) {
 664                                 int name_search_ret;
 665
 666                                 if (opt_jul) {
 667                                         enum lttng_loglevel_jul loglevel;
 668
 669                                         name_search_ret =
 670                                                 loglevel_jul_name_to_value(opt_loglevel, &loglevel);
 671                                         ev->loglevel = (int) loglevel;
 672                                 } else if (opt_log4j) {
 673                                         enum lttng_loglevel_log4j loglevel;
 674
 675                                         name_search_ret = loglevel_log4j_name_to_value(opt_loglevel,
 676                                                                                        &loglevel);
 677                                         ev->loglevel = (int) loglevel;
 678                                 } else {
 679                                         /* python domain. */
 680                                         enum lttng_loglevel_python loglevel;
 681
 682                                         name_search_ret = loglevel_python_name_to_value(
 683                                                 opt_loglevel, &loglevel);
 684                                         ev->loglevel = (int) loglevel;
 685                                 }
 686
 687                                 if (name_search_ret) {
 688                                         ERR("Unknown loglevel %s", opt_loglevel);
 689                                         ret = -LTTNG_ERR_INVALID;
 690                                         goto error;
 691                                 }
 692                         } else {
 693                                 if (opt_jul) {
 694                                         ev->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
 695                                 } else if (opt_log4j) {
 696                                         ev->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
 697                                 } else if (opt_python) {
 698                                         ev->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
 699                                 }
 700                         }
 701                         ev->type = LTTNG_EVENT_TRACEPOINT;
 702                         strncpy(ev->name, pattern.c_str(), LTTNG_SYMBOL_NAME_LEN);
 703                         ev->name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 704                 } else {
 705                         abort();
 706                 }
 707
 708                 if (!opt_filter) {
 709                         char *exclusion_string;
 710
 711                         command_ret = lttng_enable_event_with_exclusions(
 712                                 handle,
 713                                 ev,
 714                                 channel_name,
 715                                 nullptr,
 716                                 lttng_dynamic_pointer_array_get_count(&exclusions),
 717                                 (char **) exclusions.array.buffer.data);
 718                         exclusion_string = print_exclusions(&exclusions);
 719                         if (!exclusion_string) {
 720                                 PERROR("Cannot allocate exclusion_string");
 721                                 error = 1;
 722                                 goto end;
 723                         }
 724                         if (command_ret < 0) {
 725                                 /* Turn ret to positive value to handle the positive error code */
 726                                 switch (-command_ret) {
 727                                 case LTTNG_ERR_KERN_EVENT_EXIST:
 728                                         WARN("Kernel event %s%s already enabled (channel %s, session %s)",
 729                                              pattern.c_str(),
 730                                              exclusion_string,
 731                                              print_channel_name(channel_name),
 732                                              session_name.c_str());
 733                                         warn = 1;
 734                                         break;
 735                                 case LTTNG_ERR_TRACE_ALREADY_STARTED:
 736                                 {
 737                                         const char *msg =
 738                                                 "The command tried to enable an event in a new domain for a session that has already been started once.";
 739                                         ERR("Event %s%s: %s (channel %s, session %s)",
 740                                             pattern.c_str(),
 741                                             exclusion_string,
 742                                             msg,
 743                                             print_channel_name(channel_name),
 744                                             session_name.c_str());
 745                                         error = 1;
 746                                         break;
 747                                 }
 748                                 case LTTNG_ERR_SDT_PROBE_SEMAPHORE:
 749                                         ERR("SDT probes %s guarded by semaphores are not supported (channel %s, session %s)",
 750                                             pattern.c_str(),
 751                                             print_channel_name(channel_name),
 752                                             session_name.c_str());
 753                                         error = 1;
 754                                         break;
 755                                 default:
 756                                         ERR("Event %s%s: %s (channel %s, session %s)",
 757                                             pattern.c_str(),
 758                                             exclusion_string,
 759                                             lttng_strerror(command_ret),
 760                                             command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
 761                                                     print_raw_channel_name(channel_name) :
 762                                                     print_channel_name(channel_name),
 763                                             session_name.c_str());
 764                                         error = 1;
 765                                         break;
 766                                 }
 767                                 error_holder = command_ret;
 768                         } else {
 769                                 switch (dom.type) {
 770                                 case LTTNG_DOMAIN_KERNEL:
 771                                 case LTTNG_DOMAIN_UST:
 772                                         MSG("%s event %s%s created in channel %s",
 773                                             lttng_domain_type_str(dom.type),
 774                                             pattern.c_str(),
 775                                             exclusion_string,
 776                                             print_channel_name(channel_name));
 777                                         break;
 778                                 case LTTNG_DOMAIN_JUL:
 779                                 case LTTNG_DOMAIN_LOG4J:
 780                                 case LTTNG_DOMAIN_PYTHON:
 781                                         /*
 782                                          * Don't print the default channel
 783                                          * name for agent domains.
 784                                          */
 785                                         MSG("%s event %s%s enabled",
 786                                             lttng_domain_type_str(dom.type),
 787                                             pattern.c_str(),
 788                                             exclusion_string);
 789                                         break;
 790                                 default:
 791                                         abort();
 792                                 }
 793                         }
 794                         free(exclusion_string);
 795                 }
 796
 797                 if (opt_filter) {
 798                         char *exclusion_string;
 799
 800                         /* Filter present */
 801                         ev->filter = 1;
 802
 803                         command_ret = lttng_enable_event_with_exclusions(
 804                                 handle,
 805                                 ev,
 806                                 channel_name,
 807                                 opt_filter,
 808                                 lttng_dynamic_pointer_array_get_count(&exclusions),
 809                                 (char **) exclusions.array.buffer.data);
 810                         exclusion_string = print_exclusions(&exclusions);
 811                         if (!exclusion_string) {
 812                                 PERROR("Cannot allocate exclusion_string");
 813                                 error = 1;
 814                                 goto end;
 815                         }
 816                         if (command_ret < 0) {
 817                                 switch (-command_ret) {
 818                                 case LTTNG_ERR_FILTER_EXIST:
 819                                         WARN("Filter on event %s%s is already enabled"
 820                                              " (channel %s, session %s)",
 821                                              pattern.c_str(),
 822                                              exclusion_string,
 823                                              print_channel_name(channel_name),
 824                                              session_name.c_str());
 825                                         warn = 1;
 826                                         break;
 827                                 case LTTNG_ERR_TRACE_ALREADY_STARTED:
 828                                 {
 829                                         const char *msg =
 830                                                 "The command tried to enable an event in a new domain for a session that has already been started once.";
 831                                         ERR("Event %s%s: %s (channel %s, session %s, filter \'%s\')",
 832                                             ev->name,
 833                                             exclusion_string,
 834                                             msg,
 835                                             print_channel_name(channel_name),
 836                                             session_name.c_str(),
 837                                             opt_filter);
 838                                         error = 1;
 839                                         break;
 840                                 }
 841                                 default:
 842                                         ERR("Event %s%s: %s (channel %s, session %s, filter \'%s\')",
 843                                             ev->name,
 844                                             exclusion_string,
 845                                             lttng_strerror(command_ret),
 846                                             command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
 847                                                     print_raw_channel_name(channel_name) :
 848                                                     print_channel_name(channel_name),
 849                                             session_name.c_str(),
 850                                             opt_filter);
 851                                         error = 1;
 852                                         break;
 853                                 }
 854                                 error_holder = command_ret;
 855
 856                         } else {
 857                                 MSG("Event %s%s: Filter '%s' successfully set",
 858                                     pattern.c_str(),
 859                                     exclusion_string,
 860                                     opt_filter);
 861                         }
 862                         free(exclusion_string);
 863                 }
 864
 865                 if (lttng_opt_mi) {
 866                         if (command_ret) {
 867                                 success = 0;
 868                                 ev->enabled = 0;
 869                         } else {
 870                                 ev->enabled = 1;
 871                         }
 872
 873                         ret = mi_lttng_event(writer.get(), ev, 1, handle->domain.type);
 874                         if (ret) {
 875                                 ret = CMD_ERROR;
 876                                 goto error;
 877                         }
 878
 879                         /* print exclusion */
 880                         ret = mi_print_exclusion(&exclusions);
 881                         if (ret) {
 882                                 ret = CMD_ERROR;
 883                                 goto error;
 884                         }
 885
 886                         /* Success ? */
 887                         ret = mi_lttng_writer_write_element_bool(
 888                                 writer.get(), mi_lttng_element_command_success, success);
 889                         if (ret) {
 890                                 ret = CMD_ERROR;
 891                                 goto end;
 892                         }
 893
 894                         /* Close event element */
 895                         ret = mi_lttng_writer_close_element(writer.get());
 896                         if (ret) {
 897                                 ret = CMD_ERROR;
 898                                 goto end;
 899                         }
 900                 }
 901
 902                 /* Reset warn, error and success */
 903                 success = 1;
 904         }
 905
 906 end:
 907         /* Close Mi */
 908         if (lttng_opt_mi) {
 909                 /* Close events element */
 910                 ret = mi_lttng_writer_close_element(writer.get());
 911                 if (ret) {
 912                         ret = CMD_ERROR;
 913                         goto error;
 914                 }
 915         }
 916 error:
 917         if (warn) {
 918                 ret = CMD_WARNING;
 919         }
 920         if (error) {
 921                 ret = CMD_ERROR;
 922         }
 923         lttng_destroy_handle(handle);
 924         lttng_dynamic_pointer_array_reset(&exclusions);
 925         lttng_userspace_probe_location_destroy(uprobe_loc);
 926
 927         /* Overwrite ret with error_holder if there was an actual error with
 928          * enabling an event.
 929          */
 930         ret = error_holder ? error_holder : ret;
 931
 932         lttng_event_destroy(ev);
 933         return ret;
 934 }
 935
 936 void _poptContextFree_deleter_func(poptContext ctx)
 937 {
 938         poptFreeContext(ctx);
 939 }
 940
 941 } /* namespace */
 942
 943 int validate_exclusion_list(const char *pattern,
 944                             const struct lttng_dynamic_pointer_array *exclusions)
 945 {
 946         int ret;
 947
 948         /* Event name must be a valid globbing pattern to allow exclusions. */
 949         if (!strutils_is_star_glob_pattern(pattern)) {
 950                 ERR("Event %s: Exclusions can only be used with a globbing pattern", pattern);
 951                 goto error;
 952         }
 953
 954         /*
 955          * If the event name is a star-at-end only globbing pattern,
 956          * then we can validate the individual exclusions. Otherwise
 957          * all exclusions are passed to the session daemon.
 958          */
 959         if (strutils_is_star_at_the_end_only_glob_pattern(pattern)) {
 960                 size_t i, num_exclusions;
 961
 962                 num_exclusions = lttng_dynamic_pointer_array_get_count(exclusions);
 963
 964                 for (i = 0; i < num_exclusions; i++) {
 965                         const char *exclusion =
 966                                 (const char *) lttng_dynamic_pointer_array_get_pointer(exclusions,
 967                                                                                        i);
 968
 969                         if (!strutils_is_star_glob_pattern(exclusion) ||
 970                             strutils_is_star_at_the_end_only_glob_pattern(exclusion)) {
 971                                 ret = check_exclusion_subsets(pattern, exclusion);
 972                                 if (ret) {
 973                                         goto error;
 974                                 }
 975                         }
 976                 }
 977         }
 978
 979         ret = 0;
 980         goto end;
 981
 982 error:
 983         ret = -1;
 984
 985 end:
 986         return ret;
 987 }
 988
 989 /*
 990  * Add event to trace session
 991  */
 992 int cmd_enable_events(int argc, const char **argv)
 993 {
 994         int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
 995         std::string session_name;
 996         const char *arg_event_list = nullptr;
 997         const char *leftover = nullptr;
 998         int event_type = -1;
 999         event_rule_patterns patterns;
1000
1001         auto pc = lttng::make_unique_wrapper<poptContext_s, _poptContextFree_deleter_func>(
1002                 poptGetContext(nullptr, argc, argv, long_options, 0));
1003         poptReadDefaultConfig(pc.get(), 0);
1004
1005         /* Default event type */
1006         opt_event_type = LTTNG_EVENT_ALL;
1007
1008         while ((opt = poptGetNextOpt(pc.get())) != -1) {
1009                 switch (opt) {
1010                 case OPT_HELP:
1011                         SHOW_HELP();
1012                         return CMD_SUCCESS;
1013                 case OPT_TRACEPOINT:
1014                         opt_event_type = LTTNG_EVENT_TRACEPOINT;
1015                         break;
1016                 case OPT_PROBE:
1017                         opt_event_type = LTTNG_EVENT_PROBE;
1018                         break;
1019                 case OPT_USERSPACE_PROBE:
1020                         opt_event_type = LTTNG_EVENT_USERSPACE_PROBE;
1021                         break;
1022                 case OPT_FUNCTION:
1023                         opt_event_type = LTTNG_EVENT_FUNCTION;
1024                         break;
1025                 case OPT_SYSCALL:
1026                         opt_event_type = LTTNG_EVENT_SYSCALL;
1027                         break;
1028                 case OPT_USERSPACE:
1029                         opt_userspace = 1;
1030                         break;
1031                 case OPT_LOGLEVEL:
1032                         opt_loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
1033                         opt_loglevel = poptGetOptArg(pc.get());
1034                         break;
1035                 case OPT_LOGLEVEL_ONLY:
1036                         opt_loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
1037                         opt_loglevel = poptGetOptArg(pc.get());
1038                         break;
1039                 case OPT_LIST_OPTIONS:
1040                         list_cmd_options(stdout, long_options);
1041                         return CMD_SUCCESS;
1042                 case OPT_FILTER:
1043                         break;
1044                 case OPT_EXCLUDE:
1045                         break;
1046                 default:
1047                         return CMD_UNDEFINED;
1048                 }
1049
1050                 /* Validate event type. Multiple event type are not supported. */
1051                 if (event_type == -1) {
1052                         event_type = opt_event_type;
1053                 } else {
1054                         if (event_type != opt_event_type) {
1055                                 ERR("Multiple event type not supported.");
1056                                 return CMD_ERROR;
1057                         }
1058                 }
1059         }
1060
1061         ret = print_missing_or_multiple_domains(
1062                 opt_kernel + opt_userspace + opt_jul + opt_log4j + opt_python, true);
1063         if (ret) {
1064                 return CMD_ERROR;
1065         }
1066
1067         /* Mi check */
1068         if (lttng_opt_mi) {
1069                 writer = mi_writer_uptr(mi_lttng_writer_create(fileno(stdout), lttng_opt_mi));
1070                 if (!writer) {
1071                         LTTNG_THROW_ERROR(lttng::format(
1072                                 "Failed to create MI writer: format_code={}", lttng_opt_mi));
1073                 }
1074
1075                 /* Open command element */
1076                 ret = mi_lttng_writer_command_open(writer.get(),
1077                                                    mi_lttng_element_command_enable_event);
1078                 if (ret) {
1079                         LTTNG_THROW_ERROR(lttng::format(
1080                                 "Failed to open MI command element: command_name=`{}`",
1081                                 mi_lttng_element_command_enable_event));
1082                 }
1083
1084                 /* Open output element */
1085                 ret = mi_lttng_writer_open_element(writer.get(), mi_lttng_element_command_output);
1086                 if (ret) {
1087                         LTTNG_THROW_ERROR(
1088                                 lttng::format("Failed to open MI element: element_name=`{}`",
1089                                               mi_lttng_element_command_output));
1090                 }
1091         }
1092
1093         /* Close the MI command context when leaving the function, no matter the result. */
1094         const auto close_mi_on_exit = lttng::make_scope_exit([&success]() noexcept {
1095                 if (!lttng_opt_mi) {
1096                         return;
1097                 }
1098
1099                 /* Close output element. */
1100                 if (mi_lttng_writer_close_element(writer.get())) {
1101                         ERR_FMT("Failed to close MI output element");
1102                         return;
1103                 }
1104
1105                 if (mi_lttng_writer_write_element_bool(
1106                             writer.get(), mi_lttng_element_command_success, success)) {
1107                         ERR_FMT("Failed to write MI element: element_name=`{}`, value={}",
1108                                 mi_lttng_element_command_success,
1109                                 success);
1110                         return;
1111                 }
1112
1113                 /* Command element close. */
1114                 if (mi_lttng_writer_command_close(writer.get())) {
1115                         ERR_FMT("Failed to close MI command element");
1116                         return;
1117                 }
1118         });
1119
1120         arg_event_list = poptGetArg(pc.get());
1121         if (arg_event_list == nullptr && opt_enable_all == 0) {
1122                 ERR("Missing event name(s).");
1123                 return CMD_ERROR;
1124         }
1125
1126         if (opt_enable_all) {
1127                 patterns.emplace_back("*");
1128         } else {
1129                 std::stringstream event_list_arg_stream(arg_event_list);
1130
1131                 for (std::string line; std::getline(event_list_arg_stream, line, ',');) {
1132                         patterns.emplace_back(std::move(line));
1133                 }
1134         }
1135
1136         leftover = poptGetArg(pc.get());
1137         if (leftover) {
1138                 ERR("Unknown argument: %s", leftover);
1139                 return CMD_ERROR;
1140         }
1141
1142         if (!opt_session_name) {
1143                 const auto rc_file_session_name =
1144                         lttng::make_unique_wrapper<char, lttng::free>(get_session_name());
1145
1146                 if (!rc_file_session_name) {
1147                         return CMD_ERROR;
1148                 }
1149
1150                 session_name = rc_file_session_name.get();
1151         } else {
1152                 session_name = opt_session_name;
1153         }
1154
1155         command_ret = enable_events(session_name, patterns);
1156         if (command_ret) {
1157                 return CMD_ERROR;
1158         }
1159
1160         return CMD_SUCCESS;
1161 }