src/bin/lttng/commands/add_trigger.c

   1 /*
   2  * Copyright (C) 2021 Simon Marchi <simon.marchi@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <ctype.h>
   9 #include <stdio.h>
  10
  11 #include "../command.h"
  12 #include "../loglevel.h"
  13 #include "../uprobe.h"
  14
  15 #include "common/argpar/argpar.h"
  16 #include "common/dynamic-array.h"
  17 #include "common/string-utils/string-utils.h"
  18 #include "common/utils.h"
  19 /* For lttng_event_rule_type_str(). */
  20 #include <lttng/event-rule/event-rule-internal.h>
  21 #include <lttng/lttng.h>
  22 #include "common/filter/filter-ast.h"
  23 #include "common/filter/filter-ir.h"
  24 #include "common/dynamic-array.h"
  25
  26 #if (LTTNG_SYMBOL_NAME_LEN == 256)
  27 #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
  28 #endif
  29
  30 #ifdef LTTNG_EMBED_HELP
  31 static const char help_msg[] =
  32 #include <lttng-add-trigger.1.h>
  33 ;
  34 #endif
  35
  36 enum {
  37         OPT_HELP,
  38         OPT_LIST_OPTIONS,
  39
  40         OPT_CONDITION,
  41         OPT_ACTION,
  42         OPT_ID,
  43         OPT_FIRE_ONCE_AFTER,
  44         OPT_FIRE_EVERY,
  45         OPT_USER_ID,
  46
  47         OPT_ALL,
  48         OPT_FILTER,
  49         OPT_EXCLUDE,
  50         OPT_LOGLEVEL,
  51         OPT_LOGLEVEL_ONLY,
  52
  53         OPT_USERSPACE,
  54         OPT_KERNEL,
  55         OPT_LOG4J,
  56         OPT_JUL,
  57         OPT_PYTHON,
  58
  59         OPT_FUNCTION,
  60         OPT_PROBE,
  61         OPT_USERSPACE_PROBE,
  62         OPT_SYSCALL,
  63         OPT_TRACEPOINT,
  64
  65         OPT_NAME,
  66         OPT_MAX_SIZE,
  67         OPT_DATA_URL,
  68         OPT_CTRL_URL,
  69         OPT_URL,
  70         OPT_PATH,
  71
  72         OPT_CAPTURE,
  73 };
  74
  75 static const struct argpar_opt_descr event_rule_opt_descrs[] = {
  76         { OPT_ALL, 'a', "all", false },
  77         { OPT_FILTER, 'f', "filter", true },
  78         { OPT_EXCLUDE, 'x', "exclude", true },
  79         { OPT_LOGLEVEL, '\0', "loglevel", true },
  80         { OPT_LOGLEVEL_ONLY, '\0', "loglevel-only", true },
  81
  82         /* Domains */
  83         { OPT_USERSPACE, 'u', "userspace", false },
  84         { OPT_KERNEL, 'k', "kernel", false },
  85         { OPT_LOG4J, 'l', "log4j", false },
  86         { OPT_JUL, 'j', "jul", false },
  87         { OPT_PYTHON, 'p', "python", false },
  88
  89         /* Event rule types */
  90         { OPT_FUNCTION, '\0', "function", true },
  91         { OPT_PROBE, '\0', "probe", true },
  92         { OPT_USERSPACE_PROBE, '\0', "userspace-probe", true },
  93         { OPT_SYSCALL, '\0', "syscall" },
  94         { OPT_TRACEPOINT, '\0', "tracepoint" },
  95
  96         /* Capture descriptor */
  97         { OPT_CAPTURE, '\0', "capture", true },
  98
  99         ARGPAR_OPT_DESCR_SENTINEL
 100 };
 101
 102 static
 103 bool assign_domain_type(enum lttng_domain_type *dest,
 104                 enum lttng_domain_type src)
 105 {
 106         bool ret;
 107
 108         if (*dest == LTTNG_DOMAIN_NONE || *dest == src) {
 109                 *dest = src;
 110                 ret = true;
 111         } else {
 112                 ERR("Multiple domains specified.");
 113                 ret = false;
 114         }
 115
 116         return ret;
 117 }
 118
 119 static
 120 bool assign_event_rule_type(enum lttng_event_rule_type *dest,
 121                 enum lttng_event_rule_type src)
 122 {
 123         bool ret;
 124
 125         if (*dest == LTTNG_EVENT_RULE_TYPE_UNKNOWN || *dest == src) {
 126                 *dest = src;
 127                 ret = true;
 128         } else {
 129                 ERR("Multiple event types specified.");
 130                 ret = false;
 131         }
 132
 133         return ret;
 134 }
 135
 136 static
 137 bool assign_string(char **dest, const char *src, const char *opt_name)
 138 {
 139         bool ret;
 140
 141         if (*dest) {
 142                 ERR("Duplicate '%s' given.", opt_name);
 143                 goto error;
 144         }
 145
 146         *dest = strdup(src);
 147         if (!*dest) {
 148                 PERROR("Failed to allocate string '%s'.", opt_name);
 149                 goto error;
 150         }
 151
 152         ret = true;
 153         goto end;
 154
 155 error:
 156         ret = false;
 157
 158 end:
 159         return ret;
 160 }
 161
 162 /* This is defined in enable_events.c. */
 163 LTTNG_HIDDEN
 164 int create_exclusion_list_and_validate(const char *event_name,
 165                 const char *exclusions_arg,
 166                 char ***exclusion_list);
 167
 168 /*
 169  * Parse `str` as a log level in domain `domain_type`. Return -1 if the string
 170  * is not recognized as a valid log level.
 171  */
 172 static
 173 int parse_loglevel_string(const char *str, enum lttng_domain_type domain_type)
 174 {
 175         switch (domain_type) {
 176         case LTTNG_DOMAIN_UST:
 177         {
 178                 enum lttng_loglevel loglevel;
 179                 const int ret = loglevel_name_to_value(str, &loglevel);
 180
 181                 return ret == -1 ? ret : (int) loglevel;
 182         }
 183         case LTTNG_DOMAIN_LOG4J:
 184         {
 185                 enum lttng_loglevel_log4j loglevel;
 186                 const int ret = loglevel_log4j_name_to_value(str, &loglevel);
 187
 188                 return ret == -1 ? ret : (int) loglevel;
 189         }
 190         case LTTNG_DOMAIN_JUL:
 191         {
 192                 enum lttng_loglevel_jul loglevel;
 193                 const int ret = loglevel_jul_name_to_value(str, &loglevel);
 194
 195                 return ret == -1 ? ret : (int) loglevel;
 196         }
 197         case LTTNG_DOMAIN_PYTHON:
 198         {
 199                 enum lttng_loglevel_python loglevel;
 200                 const int ret = loglevel_python_name_to_value(str, &loglevel);
 201
 202                 return ret == -1 ? ret : (int) loglevel;
 203         }
 204         default:
 205                 /* Invalid domain type. */
 206                 abort();
 207         }
 208 }
 209
 210 static int parse_kernel_probe_opts(const char *source,
 211                 struct lttng_kernel_probe_location **location)
 212 {
 213         int ret = 0;
 214         int match;
 215         char s_hex[19];
 216         char name[LTTNG_SYMBOL_NAME_LEN];
 217         char *symbol_name = NULL;
 218         uint64_t offset;
 219
 220         /* Check for symbol+offset. */
 221         match = sscanf(source,
 222                         "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
 223                         "[^'+']+%18s",
 224                         name, s_hex);
 225         if (match == 2) {
 226                 if (*s_hex == '\0') {
 227                         ERR("Kernel probe symbol offset is missing.");
 228                         goto error;
 229                 }
 230
 231                 symbol_name = strndup(name, LTTNG_SYMBOL_NAME_LEN);
 232                 if (!symbol_name) {
 233                         PERROR("Failed to copy kernel probe location symbol name.");
 234                         goto error;
 235                 }
 236                 offset = strtoul(s_hex, NULL, 0);
 237
 238                 *location = lttng_kernel_probe_location_symbol_create(
 239                                 symbol_name, offset);
 240                 if (!*location) {
 241                         ERR("Failed to create symbol kernel probe location.");
 242                         goto error;
 243                 }
 244
 245                 goto end;
 246         }
 247
 248         /* Check for symbol. */
 249         if (isalpha(name[0]) || name[0] == '_') {
 250                 match = sscanf(source,
 251                                 "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
 252                                 "s",
 253                                 name);
 254                 if (match == 1) {
 255                         symbol_name = strndup(name, LTTNG_SYMBOL_NAME_LEN);
 256                         if (!symbol_name) {
 257                                 ERR("Failed to copy kernel probe location symbol name.");
 258                                 goto error;
 259                         }
 260
 261                         *location = lttng_kernel_probe_location_symbol_create(
 262                                         symbol_name, 0);
 263                         if (!*location) {
 264                                 ERR("Failed to create symbol kernel probe location.");
 265                                 goto error;
 266                         }
 267
 268                         goto end;
 269                 }
 270         }
 271
 272         /* Check for address. */
 273         match = sscanf(source, "%18s", s_hex);
 274         if (match > 0) {
 275                 uint64_t address;
 276
 277                 if (*s_hex == '\0') {
 278                         ERR("Invalid kernel probe location address.");
 279                         goto error;
 280                 }
 281
 282                 address = strtoul(s_hex, NULL, 0);
 283                 *location = lttng_kernel_probe_location_address_create(address);
 284                 if (!*location) {
 285                         ERR("Failed to create symbol kernel probe location.");
 286                         goto error;
 287                 }
 288
 289                 goto end;
 290         }
 291
 292 error:
 293         /* No match */
 294         ret = -1;
 295         *location = NULL;
 296
 297 end:
 298         free(symbol_name);
 299         return ret;
 300 }
 301
 302 static
 303 struct lttng_event_expr *ir_op_load_expr_to_event_expr(
 304                 const struct ir_load_expression *load_expr,
 305                 const char *capture_str)
 306 {
 307         char *provider_name = NULL;
 308         struct lttng_event_expr *event_expr = NULL;
 309         const struct ir_load_expression_op *load_expr_op = load_expr->child;
 310         const enum ir_load_expression_type load_expr_child_type =
 311                         load_expr_op->type;
 312
 313         switch (load_expr_child_type) {
 314         case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
 315         case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
 316         {
 317                 const char *field_name;
 318
 319                 load_expr_op = load_expr_op->next;
 320                 assert(load_expr_op);
 321                 assert(load_expr_op->type == IR_LOAD_EXPRESSION_GET_SYMBOL);
 322                 field_name = load_expr_op->u.symbol;
 323                 assert(field_name);
 324
 325                 event_expr = load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ?
 326                                 lttng_event_expr_event_payload_field_create(field_name) :
 327                                 lttng_event_expr_channel_context_field_create(field_name);
 328                 if (!event_expr) {
 329                         ERR("Failed to create %s event expression: field name = `%s`.",
 330                                         load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ?
 331                                                         "payload field" : "channel context",
 332                                                         field_name);
 333                         goto error;
 334                 }
 335
 336                 break;
 337         }
 338         case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
 339         {
 340                 const char *colon;
 341                 const char *type_name;
 342                 const char *field_name;
 343
 344                 load_expr_op = load_expr_op->next;
 345                 assert(load_expr_op);
 346                 assert(load_expr_op->type == IR_LOAD_EXPRESSION_GET_SYMBOL);
 347                 field_name = load_expr_op->u.symbol;
 348                 assert(field_name);
 349
 350                 /*
 351                  * The field name needs to be of the form PROVIDER:TYPE. We
 352                  * split it here.
 353                  */
 354                 colon = strchr(field_name, ':');
 355                 if (!colon) {
 356                         ERR("Invalid app-specific context field name: missing colon in `%s`.",
 357                                         field_name);
 358                         goto error;
 359                 }
 360
 361                 type_name = colon + 1;
 362                 if (*type_name == '\0') {
 363                         ERR("Invalid app-specific context field name: missing type name after colon in `%s`.",
 364                                         field_name);
 365                         goto error;
 366                 }
 367
 368                 provider_name = strndup(field_name, colon - field_name);
 369                 if (!provider_name) {
 370                         PERROR("Failed to allocate field name string");
 371                         goto error;
 372                 }
 373
 374                 event_expr = lttng_event_expr_app_specific_context_field_create(
 375                                 provider_name, type_name);
 376                 if (!event_expr) {
 377                         ERR("Failed to create app-specific context field event expression: provider name = `%s`, type name = `%s`",
 378                                         provider_name, type_name);
 379                         goto error;
 380                 }
 381
 382                 break;
 383         }
 384         default:
 385                 ERR("%s: unexpected load expr type %d.", __func__,
 386                                 load_expr_op->type);
 387                 abort();
 388         }
 389
 390         load_expr_op = load_expr_op->next;
 391
 392         /* There may be a single array index after that. */
 393         if (load_expr_op->type == IR_LOAD_EXPRESSION_GET_INDEX) {
 394                 struct lttng_event_expr *index_event_expr;
 395                 const uint64_t index = load_expr_op->u.index;
 396
 397                 index_event_expr = lttng_event_expr_array_field_element_create(event_expr, index);
 398                 if (!index_event_expr) {
 399                         ERR("Failed to create array field element event expression.");
 400                         goto error;
 401                 }
 402
 403                 event_expr = index_event_expr;
 404                 load_expr_op = load_expr_op->next;
 405         }
 406
 407         switch (load_expr_op->type) {
 408         case IR_LOAD_EXPRESSION_LOAD_FIELD:
 409                 /*
 410                  * This is what we expect, IR_LOAD_EXPRESSION_LOAD_FIELD is
 411                  * always found at the end of the chain.
 412                  */
 413                 break;
 414         case IR_LOAD_EXPRESSION_GET_SYMBOL:
 415                 ERR("While parsing expression `%s`: Capturing subfields is not supported.",
 416                                 capture_str);
 417                 goto error;
 418
 419         default:
 420                 ERR("%s: unexpected load expression operator %s.", __func__,
 421                                 ir_load_expression_type_str(load_expr_op->type));
 422                 abort();
 423         }
 424
 425         goto end;
 426
 427 error:
 428         lttng_event_expr_destroy(event_expr);
 429         event_expr = NULL;
 430
 431 end:
 432         free(provider_name);
 433
 434         return event_expr;
 435 }
 436
 437 static
 438 struct lttng_event_expr *ir_op_load_to_event_expr(
 439                 const struct ir_op *ir, const char *capture_str)
 440 {
 441         struct lttng_event_expr *event_expr = NULL;
 442
 443         assert(ir->op == IR_OP_LOAD);
 444
 445         switch (ir->data_type) {
 446         case IR_DATA_EXPRESSION:
 447         {
 448                 const struct ir_load_expression *ir_load_expr =
 449                                 ir->u.load.u.expression;
 450
 451                 event_expr = ir_op_load_expr_to_event_expr(
 452                                 ir_load_expr, capture_str);
 453                 break;
 454         }
 455         default:
 456                 ERR("%s: unexpected data type: %s.", __func__,
 457                                 ir_data_type_str(ir->data_type));
 458                 abort();
 459         }
 460
 461         return event_expr;
 462 }
 463
 464 static
 465 const char *ir_operator_type_human_str(enum ir_op_type op)
 466 {
 467         const char *name;
 468
 469         switch (op) {
 470         case IR_OP_BINARY:
 471                 name = "Binary";
 472                 break;
 473         case IR_OP_UNARY:
 474                 name = "Unary";
 475                 break;
 476         case IR_OP_LOGICAL:
 477                 name = "Logical";
 478                 break;
 479         default:
 480                 abort();
 481         }
 482
 483         return name;
 484 }
 485
 486 static
 487 struct lttng_event_expr *ir_op_root_to_event_expr(const struct ir_op *ir,
 488                 const char *capture_str)
 489 {
 490         struct lttng_event_expr *event_expr = NULL;
 491
 492         assert(ir->op == IR_OP_ROOT);
 493         ir = ir->u.root.child;
 494
 495         switch (ir->op) {
 496         case IR_OP_LOAD:
 497                 event_expr = ir_op_load_to_event_expr(ir, capture_str);
 498                 break;
 499         case IR_OP_BINARY:
 500         case IR_OP_UNARY:
 501         case IR_OP_LOGICAL:
 502                 ERR("While parsing expression `%s`: %s operators are not allowed in capture expressions.",
 503                                 capture_str,
 504                                 ir_operator_type_human_str(ir->op));
 505                 break;
 506         default:
 507                 ERR("%s: unexpected IR op type: %s.", __func__,
 508                                 ir_op_type_str(ir->op));
 509                 abort();
 510         }
 511
 512         return event_expr;
 513 }
 514
 515 static
 516 void destroy_event_expr(void *ptr)
 517 {
 518         lttng_event_expr_destroy(ptr);
 519 }
 520
 521 struct parse_event_rule_res {
 522         /* Owned by this. */
 523         struct lttng_event_rule *er;
 524
 525         /* Array of `struct lttng_event_expr *` */
 526         struct lttng_dynamic_pointer_array capture_descriptors;
 527 };
 528
 529 static
 530 struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv)
 531 {
 532         enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;
 533         enum lttng_event_rule_type event_rule_type =
 534                         LTTNG_EVENT_RULE_TYPE_UNKNOWN;
 535         struct argpar_state *state;
 536         struct argpar_item *item = NULL;
 537         char *error = NULL;
 538         int consumed_args = -1;
 539         struct lttng_kernel_probe_location *kernel_probe_location = NULL;
 540         struct lttng_userspace_probe_location *userspace_probe_location = NULL;
 541         struct parse_event_rule_res res = { 0 };
 542         struct lttng_event_expr *event_expr = NULL;
 543         struct filter_parser_ctx *parser_ctx = NULL;
 544         struct lttng_log_level_rule *log_level_rule = NULL;
 545
 546         /* Was the -a/--all flag provided? */
 547         bool all_events = false;
 548
 549         /* Tracepoint name (non-option argument). */
 550         const char *tracepoint_name = NULL;
 551
 552         /* Holds the argument of --probe / --userspace-probe. */
 553         char *source = NULL;
 554
 555         /* Filter. */
 556         char *filter = NULL;
 557
 558         /* Exclude. */
 559         char *exclude = NULL;
 560         char **exclusion_list = NULL;
 561
 562         /* Log level. */
 563         char *loglevel_str = NULL;
 564         bool loglevel_only = false;
 565
 566         lttng_dynamic_pointer_array_init(&res.capture_descriptors,
 567                                 destroy_event_expr);
 568         state = argpar_state_create(*argc, *argv, event_rule_opt_descrs);
 569         if (!state) {
 570                 ERR("Failed to allocate an argpar state.");
 571                 goto error;
 572         }
 573
 574         while (true) {
 575                 enum argpar_state_parse_next_status status;
 576
 577                 ARGPAR_ITEM_DESTROY_AND_RESET(item);
 578                 status = argpar_state_parse_next(state, &item, &error);
 579                 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
 580                         ERR("%s", error);
 581                         goto error;
 582                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
 583                         /* Just stop parsing here. */
 584                         break;
 585                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
 586                         break;
 587                 }
 588
 589                 assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
 590
 591                 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
 592                         const struct argpar_item_opt *item_opt =
 593                                         (const struct argpar_item_opt *) item;
 594
 595                         switch (item_opt->descr->id) {
 596                         /* Domains. */
 597                         case OPT_USERSPACE:
 598                                 if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_UST)) {
 599                                         goto error;
 600                                 }
 601
 602                                 break;
 603                         case OPT_KERNEL:
 604                                 if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_KERNEL)) {
 605                                         goto error;
 606                                 }
 607
 608                                 break;
 609                         case OPT_LOG4J:
 610                                 if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_LOG4J)) {
 611                                         goto error;
 612                                 }
 613
 614                                 break;
 615                         case OPT_JUL:
 616                                 if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_JUL)) {
 617                                         goto error;
 618                                 }
 619
 620                                 break;
 621                         case OPT_PYTHON:
 622                                 if (!assign_domain_type(&domain_type, LTTNG_DOMAIN_PYTHON)) {
 623                                         goto error;
 624                                 }
 625
 626                                 break;
 627
 628                         /* Event rule types */
 629                         case OPT_FUNCTION:
 630                                 if (!assign_event_rule_type(&event_rule_type,
 631                                                 LTTNG_EVENT_RULE_TYPE_KRETPROBE)) {
 632                                         goto error;
 633                                 }
 634
 635                                 break;
 636                         case OPT_PROBE:
 637                                 if (!assign_event_rule_type(&event_rule_type,
 638                                                 LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE)) {
 639                                         goto error;
 640                                 }
 641
 642                                 if (!assign_string(&source, item_opt->arg, "source")) {
 643                                         goto error;
 644                                 }
 645
 646                                 break;
 647                         case OPT_USERSPACE_PROBE:
 648                                 if (!assign_event_rule_type(&event_rule_type,
 649                                                 LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE)) {
 650                                         goto error;
 651                                 }
 652
 653                                 if (!assign_string(&source, item_opt->arg, "source")) {
 654                                                 goto error;
 655                                 }
 656
 657                                 break;
 658                         case OPT_SYSCALL:
 659                                 if (!assign_event_rule_type(&event_rule_type,
 660                                                 LTTNG_EVENT_RULE_TYPE_SYSCALL)) {
 661                                         goto error;
 662                                 }
 663
 664                                 break;
 665                         case OPT_TRACEPOINT:
 666                                 if (!assign_event_rule_type(&event_rule_type,
 667                                                 LTTNG_EVENT_RULE_TYPE_TRACEPOINT)) {
 668                                         goto error;
 669                                 }
 670
 671                                 break;
 672                         case OPT_ALL:
 673                                 all_events = true;
 674                                 break;
 675                         case OPT_FILTER:
 676                                 if (!assign_string(&filter, item_opt->arg,
 677                                                     "--filter/-f")) {
 678                                         goto error;
 679                                 }
 680
 681                                 break;
 682                         case OPT_EXCLUDE:
 683                                 if (!assign_string(&exclude, item_opt->arg,
 684                                                     "--exclude/-x")) {
 685                                         goto error;
 686                                 }
 687
 688                                 break;
 689                         case OPT_LOGLEVEL:
 690                         case OPT_LOGLEVEL_ONLY:
 691                                 if (!assign_string(&loglevel_str, item_opt->arg,
 692                                                     "--loglevel/--loglevel-only")) {
 693                                         goto error;
 694                                 }
 695
 696                                 loglevel_only = item_opt->descr->id ==
 697                                                 OPT_LOGLEVEL_ONLY;
 698                                 break;
 699                         case OPT_CAPTURE:
 700                         {
 701                                 int ret;
 702                                 const char *capture_str = item_opt->arg;
 703
 704                                 ret = filter_parser_ctx_create_from_filter_expression(
 705                                                 capture_str, &parser_ctx);
 706                                 if (ret) {
 707                                         ERR("Failed to parse capture expression `%s`.",
 708                                                         capture_str);
 709                                         goto error;
 710                                 }
 711
 712                                 event_expr = ir_op_root_to_event_expr(
 713                                                 parser_ctx->ir_root,
 714                                                 capture_str);
 715                                 if (!event_expr) {
 716                                         /*
 717                                          * ir_op_root_to_event_expr has printed
 718                                          * an error message.
 719                                          */
 720                                         goto error;
 721                                 }
 722
 723                                 ret = lttng_dynamic_pointer_array_add_pointer(
 724                                                 &res.capture_descriptors,
 725                                                 event_expr);
 726                                 if (ret) {
 727                                         goto error;
 728                                 }
 729
 730                                 /*
 731                                  * The ownership of event expression was
 732                                  * transferred to the dynamic array.
 733                                  */
 734                                 event_expr = NULL;
 735
 736                                 break;
 737                         }
 738                         default:
 739                                 abort();
 740                         }
 741                 } else {
 742                         const struct argpar_item_non_opt *item_non_opt =
 743                                         (const struct argpar_item_non_opt *)
 744                                                         item;
 745
 746                         /*
 747                          * Don't accept two non-option arguments/tracepoint
 748                          * names.
 749                          */
 750                         if (tracepoint_name) {
 751                                 ERR("Unexpected argument '%s'",
 752                                                 item_non_opt->arg);
 753                                 goto error;
 754                         }
 755
 756                         tracepoint_name = item_non_opt->arg;
 757                 }
 758         }
 759
 760         if (event_rule_type == LTTNG_EVENT_RULE_TYPE_UNKNOWN) {
 761                 event_rule_type = LTTNG_EVENT_RULE_TYPE_TRACEPOINT;
 762         }
 763
 764         /*
 765          * Option -a is applicable to event rules of type tracepoint and
 766          * syscall, and it is equivalent to using "*" as the tracepoint name.
 767          */
 768         if (all_events) {
 769                 switch (event_rule_type) {
 770                 case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
 771                 case LTTNG_EVENT_RULE_TYPE_SYSCALL:
 772                         break;
 773                 default:
 774                         ERR("Can't use -a/--all with %s event rules.",
 775                                         lttng_event_rule_type_str(event_rule_type));
 776                         goto error;
 777                 }
 778
 779                 if (tracepoint_name) {
 780                         ERR("Can't provide a tracepoint name with -a/--all.");
 781                         goto error;
 782                 }
 783
 784                 /* In which case, it's equivalent to tracepoint name "*". */
 785                 tracepoint_name = "*";
 786         }
 787
 788         /*
 789          * A tracepoint name (or -a, for the event rule types that accept it)
 790          * is required.
 791          */
 792         if (!tracepoint_name) {
 793                 ERR("Need to provide either a tracepoint name or -a/--all.");
 794                 goto error;
 795         }
 796
 797         /*
 798          * We don't support multiple tracepoint names for now.
 799          */
 800         if (strchr(tracepoint_name, ',')) {
 801                 ERR("Comma separated tracepoint names are not supported.");
 802                 goto error;
 803         }
 804
 805         /*
 806          * Update *argc and *argv so our caller can keep parsing what follows.
 807          */
 808         consumed_args = argpar_state_get_ingested_orig_args(state);
 809         assert(consumed_args >= 0);
 810         *argc -= consumed_args;
 811         *argv += consumed_args;
 812
 813         /* Need to specify a domain. */
 814         if (domain_type == LTTNG_DOMAIN_NONE) {
 815                 ERR("Please specify a domain (--kernel/--userspace/--jul/--log4j/--python).");
 816                 goto error;
 817         }
 818
 819         /* Validate event rule type against domain. */
 820         switch (event_rule_type) {
 821         case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE:
 822         case LTTNG_EVENT_RULE_TYPE_KRETPROBE:
 823         case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE:
 824         case LTTNG_EVENT_RULE_TYPE_SYSCALL:
 825                 if (domain_type != LTTNG_DOMAIN_KERNEL) {
 826                         ERR("Event type not available for user-space tracing.");
 827                         goto error;
 828                 }
 829                 break;
 830
 831         case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
 832                 break;
 833
 834         default:
 835                 abort();
 836         }
 837
 838         /*
 839          * Adding a filter to a probe, function or userspace-probe would be
 840          * denied by the kernel tracer as it's not supported at the moment. We
 841          * do an early check here to warn the user.
 842          */
 843         if (filter && domain_type == LTTNG_DOMAIN_KERNEL) {
 844                 switch (event_rule_type) {
 845                 case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
 846                 case LTTNG_EVENT_RULE_TYPE_SYSCALL:
 847                         break;
 848                 default:
 849                         ERR("Filter expressions are not supported for %s event rules.",
 850                                         lttng_event_rule_type_str(event_rule_type));
 851                         goto error;
 852                 }
 853         }
 854
 855         /* If --exclude/-x was passed, split it into an exclusion list. */
 856         if (exclude) {
 857                 if (domain_type != LTTNG_DOMAIN_UST) {
 858                         ERR("Event name exclusions are not yet implemented for %s event rules.",
 859                                         get_domain_str(domain_type));
 860                         goto error;
 861                 }
 862
 863
 864                 if (create_exclusion_list_and_validate(tracepoint_name, exclude,
 865                                 &exclusion_list) != 0) {
 866                         ERR("Failed to create exclusion list.");
 867                         goto error;
 868                 }
 869         }
 870
 871         if (loglevel_str && event_rule_type != LTTNG_EVENT_RULE_TYPE_TRACEPOINT) {
 872                 ERR("Log levels are only applicable to tracepoint event rules.");
 873                 goto error;
 874         }
 875
 876         /* Finally, create the event rule object. */
 877         switch (event_rule_type) {
 878         case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
 879         {
 880                 enum lttng_event_rule_status event_rule_status;
 881
 882                 res.er = lttng_event_rule_tracepoint_create(domain_type);
 883                 if (!res.er) {
 884                         ERR("Failed to create tracepoint event rule.");
 885                         goto error;
 886                 }
 887
 888                 /* Set pattern. */
 889                 event_rule_status = lttng_event_rule_tracepoint_set_pattern(
 890                                 res.er, tracepoint_name);
 891                 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
 892                         ERR("Failed to set tracepoint event rule's pattern to '%s'.",
 893                                         tracepoint_name);
 894                         goto error;
 895                 }
 896
 897                 /* Set filter. */
 898                 if (filter) {
 899                         event_rule_status = lttng_event_rule_tracepoint_set_filter(
 900                                         res.er, filter);
 901                         if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
 902                                 ERR("Failed to set tracepoint event rule's filter to '%s'.",
 903                                                 filter);
 904                                 goto error;
 905                         }
 906                 }
 907
 908                 /* Set exclusion list. */
 909                 if (exclusion_list) {
 910                         int n;
 911
 912                         for (n = 0; exclusion_list[n]; n++) {
 913                                 event_rule_status = lttng_event_rule_tracepoint_add_exclusion(
 914                                                 res.er,
 915                                                 exclusion_list[n]);
 916                                 if (event_rule_status !=
 917                                                 LTTNG_EVENT_RULE_STATUS_OK) {
 918                                         ERR("Failed to set tracepoint exclusion list element '%s'",
 919                                                         exclusion_list[n]);
 920                                         goto error;
 921                                 }
 922                         }
 923                 }
 924
 925                 if (loglevel_str) {
 926                         int loglevel;
 927
 928                         if (domain_type == LTTNG_DOMAIN_KERNEL) {
 929                                 ERR("Log levels are not supported by the kernel tracer.");
 930                                 goto error;
 931                         }
 932
 933                         loglevel = parse_loglevel_string(
 934                                         loglevel_str, domain_type);
 935                         if (loglevel < 0) {
 936                                 ERR("Failed to parse `%s` as a log level.",
 937                                                 loglevel_str);
 938                                 goto error;
 939                         }
 940
 941                         if (loglevel_only) {
 942                                 log_level_rule = lttng_log_level_rule_exactly_create(loglevel);
 943                         } else {
 944                                 log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(loglevel);
 945                         }
 946
 947                         if (log_level_rule == NULL) {
 948                                 ERR("Failed to create log level rule object.");
 949                                 goto error;
 950                         }
 951
 952                         event_rule_status =
 953                                         lttng_event_rule_tracepoint_set_log_level_rule(
 954                                                         res.er, log_level_rule);
 955
 956                         if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
 957                                 ERR("Failed to set log level on event fule.");
 958                                 goto error;
 959                         }
 960                 }
 961
 962                 break;
 963         }
 964         case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE:
 965         {
 966                 int ret;
 967                 enum lttng_event_rule_status event_rule_status;
 968
 969
 970                 ret = parse_kernel_probe_opts(source, &kernel_probe_location);
 971                 if (ret) {
 972                         ERR("Failed to parse kernel probe location.");
 973                         goto error;
 974                 }
 975
 976                 assert(kernel_probe_location);
 977                 res.er = lttng_event_rule_kernel_probe_create(kernel_probe_location);
 978                 if (!res.er) {
 979                         ERR("Failed to create kprobe event rule.");
 980                         goto error;
 981                 }
 982
 983                 event_rule_status = lttng_event_rule_kernel_probe_set_event_name(res.er, tracepoint_name);
 984                 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
 985                         ERR("Failed to set kprobe event rule's name to '%s'.", tracepoint_name);
 986                         goto error;
 987                 }
 988
 989                 break;
 990         }
 991         case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE:
 992         {
 993                 int ret;
 994                 enum lttng_event_rule_status event_rule_status;
 995
 996                 ret = parse_userspace_probe_opts(
 997                                 source, &userspace_probe_location);
 998                 if (ret) {
 999                         ERR("Failed to parse user space probe location.");
1000                         goto error;
1001                 }
1002
1003                 res.er = lttng_event_rule_userspace_probe_create(userspace_probe_location);
1004                 if (!res.er) {
1005                         ERR("Failed to create userspace probe event rule.");
1006                         goto error;
1007                 }
1008
1009                 event_rule_status = lttng_event_rule_userspace_probe_set_event_name(
1010                                 res.er, tracepoint_name);
1011                 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
1012                         ERR("Failed to set user space probe event rule's name to '%s'.",
1013                                         tracepoint_name);
1014                         goto error;
1015                 }
1016
1017                 break;
1018         }
1019         case LTTNG_EVENT_RULE_TYPE_SYSCALL:
1020         {
1021                 enum lttng_event_rule_status event_rule_status;
1022
1023                 res.er = lttng_event_rule_syscall_create();
1024                 if (!res.er) {
1025                         ERR("Failed to create syscall event rule.");
1026                         goto error;
1027                 }
1028
1029                 event_rule_status = lttng_event_rule_syscall_set_pattern(
1030                                 res.er, tracepoint_name);
1031                 if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
1032                         ERR("Failed to set syscall event rule's pattern to '%s'.",
1033                                         tracepoint_name);
1034                         goto error;
1035                 }
1036
1037                 if (filter) {
1038                         event_rule_status = lttng_event_rule_syscall_set_filter(
1039                                         res.er, filter);
1040                         if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
1041                                 ERR("Failed to set syscall event rule's filter to '%s'.",
1042                                                 filter);
1043                                 goto error;
1044                         }
1045                 }
1046
1047                 break;
1048         }
1049         default:
1050                 abort();
1051                 goto error;
1052         }
1053
1054         goto end;
1055
1056 error:
1057         lttng_event_rule_destroy(res.er);
1058         res.er = NULL;
1059         lttng_dynamic_pointer_array_reset(&res.capture_descriptors);
1060
1061 end:
1062         if (parser_ctx) {
1063                 filter_parser_ctx_free(parser_ctx);
1064         }
1065
1066         lttng_event_expr_destroy(event_expr);
1067         argpar_item_destroy(item);
1068         free(error);
1069         argpar_state_destroy(state);
1070         free(filter);
1071         free(exclude);
1072         free(loglevel_str);
1073         free(source);
1074         strutils_free_null_terminated_array_of_strings(exclusion_list);
1075         lttng_kernel_probe_location_destroy(kernel_probe_location);
1076         lttng_userspace_probe_location_destroy(userspace_probe_location);
1077         lttng_log_level_rule_destroy(log_level_rule);
1078         return res;
1079 }
1080
1081 static
1082 struct lttng_condition *handle_condition_event(int *argc, const char ***argv)
1083 {
1084         struct parse_event_rule_res res;
1085         struct lttng_condition *c;
1086         size_t i;
1087
1088         res = parse_event_rule(argc, argv);
1089         if (!res.er) {
1090                 c = NULL;
1091                 goto error;
1092         }
1093
1094         c = lttng_condition_on_event_create(res.er);
1095         lttng_event_rule_destroy(res.er);
1096         res.er = NULL;
1097         if (!c) {
1098                 goto error;
1099         }
1100
1101         for (i = 0; i < lttng_dynamic_pointer_array_get_count(&res.capture_descriptors);
1102                         i++) {
1103                 enum lttng_condition_status status;
1104                 struct lttng_event_expr **expr =
1105                                 lttng_dynamic_array_get_element(
1106                                         &res.capture_descriptors.array, i);
1107
1108                 assert(expr);
1109                 assert(*expr);
1110                 status = lttng_condition_on_event_append_capture_descriptor(
1111                                 c, *expr);
1112                 if (status != LTTNG_CONDITION_STATUS_OK) {
1113                         if (status == LTTNG_CONDITION_STATUS_UNSUPPORTED) {
1114                                 ERR("The capture feature is unsupported by the event-rule condition type");
1115                         }
1116
1117                         goto error;
1118                 }
1119
1120                 /* Ownership of event expression moved to `c` */
1121                 *expr = NULL;
1122         }
1123
1124         goto end;
1125
1126 error:
1127         lttng_condition_destroy(c);
1128         c = NULL;
1129
1130 end:
1131         lttng_dynamic_pointer_array_reset(&res.capture_descriptors);
1132         lttng_event_rule_destroy(res.er);
1133         return c;
1134 }
1135
1136 static
1137 struct lttng_condition *handle_condition_session_consumed_size(int *argc, const char ***argv)
1138 {
1139         struct lttng_condition *cond = NULL;
1140         struct argpar_state *state = NULL;
1141         struct argpar_item *item = NULL;
1142         const char *threshold_arg = NULL;
1143         const char *session_name_arg = NULL;
1144         uint64_t threshold;
1145         char *error = NULL;
1146         enum lttng_condition_status condition_status;
1147
1148         state = argpar_state_create(*argc, *argv, event_rule_opt_descrs);
1149         if (!state) {
1150                 ERR("Failed to allocate an argpar state.");
1151                 goto error;
1152         }
1153
1154         while (true) {
1155                 enum argpar_state_parse_next_status status;
1156
1157                 ARGPAR_ITEM_DESTROY_AND_RESET(item);
1158                 status = argpar_state_parse_next(state, &item, &error);
1159                 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
1160                         ERR("%s", error);
1161                         goto error;
1162                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
1163                         /* Just stop parsing here. */
1164                         break;
1165                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
1166                         break;
1167                 }
1168
1169                 assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
1170
1171                 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
1172                         const struct argpar_item_opt *item_opt =
1173                                         (const struct argpar_item_opt *) item;
1174
1175                         switch (item_opt->descr->id) {
1176                         default:
1177                                 abort();
1178                         }
1179                 } else {
1180                         const struct argpar_item_non_opt *item_non_opt;
1181
1182                         assert(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
1183
1184                         item_non_opt = (const struct argpar_item_non_opt *) item;
1185
1186                         switch (item_non_opt->non_opt_index) {
1187                         case 0:
1188                                 session_name_arg = item_non_opt->arg;
1189                                 break;
1190                         case 1:
1191                                 threshold_arg = item_non_opt->arg;
1192                                 break;
1193                         default:
1194                                 ERR("Unexpected argument `%s`.",
1195                                                 item_non_opt->arg);
1196                                 goto error;
1197                         }
1198                 }
1199         }
1200
1201         *argc -= argpar_state_get_ingested_orig_args(state);
1202         *argv += argpar_state_get_ingested_orig_args(state);
1203
1204         if (!session_name_arg) {
1205                 ERR("Missing session name argument.");
1206                 goto error;
1207         }
1208
1209         if (!threshold_arg) {
1210                 ERR("Missing threshold argument.");
1211                 goto error;
1212         }
1213
1214         if (utils_parse_size_suffix(threshold_arg, &threshold) != 0) {
1215                 ERR("Failed to parse `%s` as a size.", threshold_arg);
1216                 goto error;
1217         }
1218
1219         cond = lttng_condition_session_consumed_size_create();
1220         if (!cond) {
1221                 ERR("Failed to allocate a session consumed size condition.");
1222                 goto error;
1223         }
1224
1225         condition_status = lttng_condition_session_consumed_size_set_session_name(
1226                 cond, session_name_arg);
1227         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1228                 ERR("Failed to set session consumed size condition's session name to '%s'.",
1229                                 session_name_arg);
1230                 goto error;
1231         }
1232
1233         condition_status = lttng_condition_session_consumed_size_set_threshold(
1234                         cond, threshold);
1235         if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1236                 ERR("Failed to set session consumed size condition threshold.");
1237                 goto error;
1238         }
1239
1240         goto end;
1241
1242 error:
1243         lttng_condition_destroy(cond);
1244         cond = NULL;
1245
1246 end:
1247         argpar_state_destroy(state);
1248         argpar_item_destroy(item);
1249         free(error);
1250         return cond;
1251 }
1252
1253 static
1254 struct lttng_condition *handle_condition_buffer_usage_high(int *argc, const char ***argv)
1255 {
1256         ERR("High buffer usage threshold conditions are unsupported for the moment.");
1257         return NULL;
1258 }
1259
1260 static
1261 struct lttng_condition *handle_condition_buffer_usage_low(int *argc, const char ***argv)
1262 {
1263         ERR("Low buffer usage threshold conditions are unsupported for the moment.");
1264         return NULL;
1265 }
1266
1267 static
1268 struct lttng_condition *handle_condition_session_rotation_ongoing(int *argc, const char ***argv)
1269 {
1270         ERR("Session rotation ongoing conditions are unsupported for the moment.");
1271         return NULL;
1272 }
1273
1274 static
1275 struct lttng_condition *handle_condition_session_rotation_completed(int *argc, const char ***argv)
1276 {
1277         ERR("Session rotation completed conditions are unsupported for the moment.");
1278         return NULL;
1279 }
1280
1281 struct condition_descr {
1282         const char *name;
1283         struct lttng_condition *(*handler) (int *argc, const char ***argv);
1284 };
1285
1286 static const
1287 struct condition_descr condition_descrs[] = {
1288         { "on-event", handle_condition_event },
1289         { "on-session-consumed-size", handle_condition_session_consumed_size },
1290         { "on-buffer-usage-high", handle_condition_buffer_usage_high },
1291         { "on-buffer-usage-low", handle_condition_buffer_usage_low },
1292         { "on-session-rotation-ongoing", handle_condition_session_rotation_ongoing },
1293         { "on-session-rotation-completed", handle_condition_session_rotation_completed },
1294 };
1295
1296 static
1297 struct lttng_condition *parse_condition(int *argc, const char ***argv)
1298 {
1299         int i;
1300         struct lttng_condition *cond;
1301         const char *condition_name;
1302         const struct condition_descr *descr = NULL;
1303
1304         if (*argc == 0) {
1305                 ERR("Missing condition name.");
1306                 goto error;
1307         }
1308
1309         condition_name = (*argv)[0];
1310
1311         (*argc)--;
1312         (*argv)++;
1313
1314         for (i = 0; i < ARRAY_SIZE(condition_descrs); i++) {
1315                 if (strcmp(condition_name, condition_descrs[i].name) == 0) {
1316                         descr = &condition_descrs[i];
1317                         break;
1318                 }
1319         }
1320
1321         if (!descr) {
1322                 ERR("Unknown condition name '%s'", condition_name);
1323                 goto error;
1324         }
1325
1326         cond = descr->handler(argc, argv);
1327         if (!cond) {
1328                 /* The handler has already printed an error message. */
1329                 goto error;
1330         }
1331
1332         goto end;
1333 error:
1334         cond = NULL;
1335 end:
1336         return cond;
1337 }
1338
1339
1340 static
1341 struct lttng_action *handle_action_notify(int *argc, const char ***argv)
1342 {
1343         return lttng_action_notify_create();
1344 }
1345
1346 static const struct argpar_opt_descr no_opt_descrs[] = {
1347         ARGPAR_OPT_DESCR_SENTINEL
1348 };
1349
1350 /*
1351  * Generic handler for a kind of action that takes a session name as its sole
1352  * argument.
1353  */
1354
1355 static
1356 struct lttng_action *handle_action_simple_session(
1357                 int *argc, const char ***argv,
1358                 struct lttng_action *(*create_action_cb)(void),
1359                 enum lttng_action_status (*set_session_name_cb)(struct lttng_action *, const char *),
1360                 const char *action_name)
1361 {
1362         struct lttng_action *action = NULL;
1363         struct argpar_state *state = NULL;
1364         struct argpar_item *item = NULL;
1365         const char *session_name_arg = NULL;
1366         char *error = NULL;
1367         enum lttng_action_status action_status;
1368
1369         state = argpar_state_create(*argc, *argv, no_opt_descrs);
1370         if (!state) {
1371                 ERR("Failed to allocate an argpar state.");
1372                 goto error;
1373         }
1374
1375         while (true) {
1376                 enum argpar_state_parse_next_status status;
1377                 const struct argpar_item_non_opt *item_non_opt;
1378
1379                 ARGPAR_ITEM_DESTROY_AND_RESET(item);
1380                 status = argpar_state_parse_next(state, &item, &error);
1381                 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
1382                         ERR("%s", error);
1383                         goto error;
1384                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
1385                         /* Just stop parsing here. */
1386                         break;
1387                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
1388                         break;
1389                 }
1390
1391                 assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
1392                 assert(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
1393
1394                 item_non_opt = (const struct argpar_item_non_opt *) item;
1395
1396                 switch (item_non_opt->non_opt_index) {
1397                 case 0:
1398                         session_name_arg = item_non_opt->arg;
1399                         break;
1400                 default:
1401                         ERR("Unexpected argument `%s`.", item_non_opt->arg);
1402                         goto error;
1403                 }
1404         }
1405
1406         *argc -= argpar_state_get_ingested_orig_args(state);
1407         *argv += argpar_state_get_ingested_orig_args(state);
1408
1409         if (!session_name_arg) {
1410                 ERR("Missing session name.");
1411                 goto error;
1412         }
1413
1414         action = create_action_cb();
1415         if (!action) {
1416                 ERR("Failed to allocate %s session action.", action_name);
1417                 goto error;
1418         }
1419
1420         action_status = set_session_name_cb(action, session_name_arg);
1421         if (action_status != LTTNG_ACTION_STATUS_OK) {
1422                 ERR("Failed to set action %s session's session name to '%s'.",
1423                                 action_name, session_name_arg);
1424                 goto error;
1425         }
1426
1427         goto end;
1428
1429 error:
1430         lttng_action_destroy(action);
1431         action = NULL;
1432         argpar_item_destroy(item);
1433 end:
1434         free(error);
1435         argpar_state_destroy(state);
1436         return action;
1437 }
1438
1439 static
1440 struct lttng_action *handle_action_start_session(int *argc,
1441                 const char ***argv)
1442 {
1443         return handle_action_simple_session(argc, argv,
1444                 lttng_action_start_session_create,
1445                 lttng_action_start_session_set_session_name,
1446                 "start");
1447 }
1448
1449 static
1450 struct lttng_action *handle_action_stop_session(int *argc,
1451                 const char ***argv)
1452 {
1453         return handle_action_simple_session(argc, argv,
1454                 lttng_action_stop_session_create,
1455                 lttng_action_stop_session_set_session_name,
1456                 "stop");
1457 }
1458
1459 static
1460 struct lttng_action *handle_action_rotate_session(int *argc,
1461                 const char ***argv)
1462 {
1463         return handle_action_simple_session(argc, argv,
1464                 lttng_action_rotate_session_create,
1465                 lttng_action_rotate_session_set_session_name,
1466                 "rotate");
1467 }
1468
1469 static const struct argpar_opt_descr snapshot_action_opt_descrs[] = {
1470         { OPT_NAME, 'n', "name", true },
1471         { OPT_MAX_SIZE, 'm', "max-size", true },
1472         { OPT_CTRL_URL, '\0', "ctrl-url", true },
1473         { OPT_DATA_URL, '\0', "data-url", true },
1474         { OPT_URL, '\0', "url", true },
1475         { OPT_PATH, '\0', "path", true },
1476         ARGPAR_OPT_DESCR_SENTINEL
1477 };
1478
1479 static
1480 struct lttng_action *handle_action_snapshot_session(int *argc,
1481                 const char ***argv)
1482 {
1483         struct lttng_action *action = NULL;
1484         struct argpar_state *state = NULL;
1485         struct argpar_item *item = NULL;
1486         const char *session_name_arg = NULL;
1487         char *snapshot_name_arg = NULL;
1488         char *ctrl_url_arg = NULL;
1489         char *data_url_arg = NULL;
1490         char *max_size_arg = NULL;
1491         char *url_arg = NULL;
1492         char *path_arg = NULL;
1493         char *error = NULL;
1494         enum lttng_action_status action_status;
1495         struct lttng_snapshot_output *snapshot_output = NULL;
1496         int ret;
1497         unsigned int locations_specified = 0;
1498
1499         state = argpar_state_create(*argc, *argv, snapshot_action_opt_descrs);
1500         if (!state) {
1501                 ERR("Failed to allocate an argpar state.");
1502                 goto error;
1503         }
1504
1505         while (true) {
1506                 enum argpar_state_parse_next_status status;
1507
1508                 ARGPAR_ITEM_DESTROY_AND_RESET(item);
1509                 status = argpar_state_parse_next(state, &item, &error);
1510                 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
1511                         ERR("%s", error);
1512                         goto error;
1513                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
1514                         /* Just stop parsing here. */
1515                         break;
1516                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
1517                         break;
1518                 }
1519
1520                 assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
1521
1522                 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
1523                         const struct argpar_item_opt *item_opt =
1524                                         (const struct argpar_item_opt *) item;
1525
1526                         switch (item_opt->descr->id) {
1527                         case OPT_NAME:
1528                                 if (!assign_string(&snapshot_name_arg, item_opt->arg, "--name/-n")) {
1529                                         goto error;
1530                                 }
1531
1532                                 break;
1533                         case OPT_MAX_SIZE:
1534                                 if (!assign_string(&max_size_arg, item_opt->arg, "--max-size/-m")) {
1535                                         goto error;
1536                                 }
1537
1538                                 break;
1539                         case OPT_CTRL_URL:
1540                                 if (!assign_string(&ctrl_url_arg, item_opt->arg, "--ctrl-url")) {
1541                                         goto error;
1542                                 }
1543
1544                                 break;
1545                         case OPT_DATA_URL:
1546                                 if (!assign_string(&data_url_arg, item_opt->arg, "--data-url")) {
1547                                         goto error;
1548                                 }
1549
1550                                 break;
1551                         case OPT_URL:
1552                                 if (!assign_string(&url_arg, item_opt->arg, "--url")) {
1553                                         goto error;
1554                                 }
1555
1556                                 break;
1557                         case OPT_PATH:
1558                                 if (!assign_string(&path_arg, item_opt->arg, "--path")) {
1559                                         goto error;
1560                                 }
1561
1562                                 break;
1563                         default:
1564                                 abort();
1565                         }
1566                 } else {
1567                         const struct argpar_item_non_opt *item_non_opt;
1568
1569                         assert(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
1570
1571                         item_non_opt = (const struct argpar_item_non_opt *) item;
1572
1573                         switch (item_non_opt->non_opt_index) {
1574                         case 0:
1575                                 session_name_arg = item_non_opt->arg;
1576                                 break;
1577                         default:
1578                                 ERR("Unexpected argument `%s`.",
1579                                                 item_non_opt->arg);
1580                                 goto error;
1581                         }
1582                 }
1583         }
1584
1585         *argc -= argpar_state_get_ingested_orig_args(state);
1586         *argv += argpar_state_get_ingested_orig_args(state);
1587
1588         if (!session_name_arg) {
1589                 ERR("Missing session name.");
1590                 goto error;
1591         }
1592
1593         /* --ctrl-url and --data-url must come in pair. */
1594         if (ctrl_url_arg && !data_url_arg) {
1595                 ERR("--ctrl-url is specified, but --data-url is missing.");
1596                 goto error;
1597         }
1598
1599         if (!ctrl_url_arg && data_url_arg) {
1600                 ERR("--data-url is specified, but --ctrl-url is missing.");
1601                 goto error;
1602         }
1603
1604         locations_specified += !!(ctrl_url_arg || data_url_arg);
1605         locations_specified += !!url_arg;
1606         locations_specified += !!path_arg;
1607
1608         /* --ctrl-url/--data-url, --url and --path are mutually exclusive. */
1609         if (locations_specified > 1) {
1610                 ERR("The --ctrl-url/--data-url, --url, and --path options can't be used together.");
1611                 goto error;
1612         }
1613
1614         /*
1615          * Did the user specify an option that implies using a
1616          * custom/unregistered output?
1617          */
1618         if (url_arg || ctrl_url_arg || path_arg) {
1619                 snapshot_output = lttng_snapshot_output_create();
1620                 if (!snapshot_output) {
1621                         ERR("Failed to allocate a snapshot output.");
1622                         goto error;
1623                 }
1624         }
1625
1626         action = lttng_action_snapshot_session_create();
1627         if (!action) {
1628                 ERR("Failed to allocate snapshot session action.");
1629                 goto error;
1630         }
1631
1632         action_status = lttng_action_snapshot_session_set_session_name(
1633                         action, session_name_arg);
1634         if (action_status != LTTNG_ACTION_STATUS_OK) {
1635                 ERR("Failed to set action snapshot session's session name to '%s'.",
1636                                 session_name_arg);
1637                 goto error;
1638         }
1639
1640         if (snapshot_name_arg) {
1641                 if (!snapshot_output) {
1642                         ERR("Can't provide a snapshot output name without a snapshot output destination.");
1643                         goto error;
1644                 }
1645
1646                 ret = lttng_snapshot_output_set_name(
1647                                 snapshot_name_arg, snapshot_output);
1648                 if (ret != 0) {
1649                         ERR("Failed to set name of snapshot output.");
1650                         goto error;
1651                 }
1652         }
1653
1654         if (max_size_arg) {
1655                 uint64_t max_size;
1656
1657                 if (!snapshot_output) {
1658                         ERR("Can't provide a snapshot output max size without a snapshot output destination.");
1659                         goto error;
1660                 }
1661
1662                 ret = utils_parse_size_suffix(max_size_arg, &max_size);
1663                 if (ret != 0) {
1664                         ERR("Failed to parse `%s` as a size.", max_size_arg);
1665                         goto error;
1666                 }
1667
1668                 ret = lttng_snapshot_output_set_size(max_size, snapshot_output);
1669                 if (ret != 0) {
1670                         ERR("Failed to set snapshot output's max size to %" PRIu64 " bytes.",
1671                                         max_size);
1672                         goto error;
1673                 }
1674         }
1675
1676         if (url_arg) {
1677                 int num_uris;
1678                 struct lttng_uri *uris;
1679
1680                 if (!strstr(url_arg, "://")) {
1681                         ERR("Failed to parse '%s' as an URL.", url_arg);
1682                         goto error;
1683                 }
1684
1685                 num_uris = uri_parse_str_urls(url_arg, NULL, &uris);
1686                 if (num_uris < 1) {
1687                         ERR("Failed to parse '%s' as an URL.", url_arg);
1688                         goto error;
1689                 }
1690
1691                 if (uris[0].dtype == LTTNG_DST_PATH) {
1692                         ret = lttng_snapshot_output_set_local_path(
1693                                         uris[0].dst.path, snapshot_output);
1694                         free(uris);
1695                         if (ret != 0) {
1696                                 ERR("Failed to assign '%s' as a local destination.",
1697                                                 url_arg);
1698                                 goto error;
1699                         }
1700                 } else {
1701                         ret = lttng_snapshot_output_set_network_url(
1702                                         url_arg, snapshot_output);
1703                         free(uris);
1704                         if (ret != 0) {
1705                                 ERR("Failed to assign '%s' as a network URL.",
1706                                                 url_arg);
1707                                 goto error;
1708                         }
1709                 }
1710         }
1711
1712         if (path_arg) {
1713                 ret = lttng_snapshot_output_set_local_path(
1714                                 path_arg, snapshot_output);
1715                 if (ret != 0) {
1716                         ERR("Failed to parse '%s' as a local path.", path_arg);
1717                         goto error;
1718                 }
1719         }
1720
1721         if (ctrl_url_arg) {
1722                 /*
1723                  * Two argument form, network output with separate control and
1724                  * data URLs.
1725                  */
1726                 ret = lttng_snapshot_output_set_network_urls(
1727                                 ctrl_url_arg, data_url_arg, snapshot_output);
1728                 if (ret != 0) {
1729                         ERR("Failed to parse `%s` and `%s` as control and data URLs.",
1730                                         ctrl_url_arg, data_url_arg);
1731                         goto error;
1732                 }
1733         }
1734
1735         if (snapshot_output) {
1736                 action_status = lttng_action_snapshot_session_set_output(
1737                                 action, snapshot_output);
1738                 if (action_status != LTTNG_ACTION_STATUS_OK) {
1739                         ERR("Failed to set snapshot session action's output.");
1740                         goto error;
1741                 }
1742
1743                 /* Ownership of `snapshot_output` has been transferred to the action. */
1744                 snapshot_output = NULL;
1745         }
1746
1747         goto end;
1748
1749 error:
1750         lttng_action_destroy(action);
1751         action = NULL;
1752         free(error);
1753 end:
1754         free(snapshot_name_arg);
1755         free(path_arg);
1756         free(url_arg);
1757         free(ctrl_url_arg);
1758         free(data_url_arg);
1759         free(snapshot_output);
1760         free(max_size_arg);
1761         argpar_state_destroy(state);
1762         argpar_item_destroy(item);
1763         return action;
1764 }
1765
1766 struct action_descr {
1767         const char *name;
1768         struct lttng_action *(*handler) (int *argc, const char ***argv);
1769 };
1770
1771 static const
1772 struct action_descr action_descrs[] = {
1773         { "notify", handle_action_notify },
1774         { "start-session", handle_action_start_session },
1775         { "stop-session", handle_action_stop_session },
1776         { "rotate-session", handle_action_rotate_session },
1777         { "snapshot-session", handle_action_snapshot_session },
1778 };
1779
1780 static
1781 struct lttng_action *parse_action(int *argc, const char ***argv)
1782 {
1783         int i;
1784         struct lttng_action *action;
1785         const char *action_name;
1786         const struct action_descr *descr = NULL;
1787
1788         if (*argc == 0) {
1789                 ERR("Missing action name.");
1790                 goto error;
1791         }
1792
1793         action_name = (*argv)[0];
1794
1795         (*argc)--;
1796         (*argv)++;
1797
1798         for (i = 0; i < ARRAY_SIZE(action_descrs); i++) {
1799                 if (strcmp(action_name, action_descrs[i].name) == 0) {
1800                         descr = &action_descrs[i];
1801                         break;
1802                 }
1803         }
1804
1805         if (!descr) {
1806                 ERR("Unknown action name: %s", action_name);
1807                 goto error;
1808         }
1809
1810         action = descr->handler(argc, argv);
1811         if (!action) {
1812                 /* The handler has already printed an error message. */
1813                 goto error;
1814         }
1815
1816         goto end;
1817 error:
1818         action = NULL;
1819 end:
1820         return action;
1821 }
1822
1823 static const
1824 struct argpar_opt_descr add_trigger_options[] = {
1825         { OPT_HELP, 'h', "help", false },
1826         { OPT_LIST_OPTIONS, '\0', "list-options", false },
1827         { OPT_CONDITION, '\0', "condition", false },
1828         { OPT_ACTION, '\0', "action", false },
1829         { OPT_ID, '\0', "id", true },
1830         { OPT_FIRE_ONCE_AFTER, '\0', "fire-once-after", true },
1831         { OPT_FIRE_EVERY, '\0', "fire-every", true },
1832         { OPT_USER_ID, '\0', "user-id", true },
1833         ARGPAR_OPT_DESCR_SENTINEL,
1834 };
1835
1836 static
1837 void lttng_actions_destructor(void *p)
1838 {
1839         struct lttng_action *action = p;
1840
1841         lttng_action_destroy(action);
1842 }
1843
1844 int cmd_add_trigger(int argc, const char **argv)
1845 {
1846         int ret;
1847         int my_argc = argc - 1;
1848         const char **my_argv = argv + 1;
1849         struct lttng_condition *condition = NULL;
1850         struct lttng_dynamic_pointer_array actions;
1851         struct argpar_state *argpar_state = NULL;
1852         struct argpar_item *argpar_item = NULL;
1853         struct lttng_action *action_group = NULL;
1854         struct lttng_action *action = NULL;
1855         struct lttng_trigger *trigger = NULL;
1856         char *error = NULL;
1857         char *id = NULL;
1858         int i;
1859         char *fire_once_after_str = NULL;
1860         char *fire_every_str = NULL;
1861         char *user_id = NULL;
1862
1863         lttng_dynamic_pointer_array_init(&actions, lttng_actions_destructor);
1864
1865         while (true) {
1866                 enum argpar_state_parse_next_status status;
1867                 const struct argpar_item_opt *item_opt;
1868                 int ingested_args;
1869
1870                 argpar_state_destroy(argpar_state);
1871                 argpar_state = argpar_state_create(my_argc, my_argv,
1872                         add_trigger_options);
1873                 if (!argpar_state) {
1874                         ERR("Failed to create argpar state.");
1875                         goto error;
1876                 }
1877
1878                 ARGPAR_ITEM_DESTROY_AND_RESET(argpar_item);
1879                 status = argpar_state_parse_next(argpar_state, &argpar_item, &error);
1880                 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
1881                         ERR("%s", error);
1882                         goto error;
1883                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
1884                         ERR("%s", error);
1885                         goto error;
1886                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
1887                         break;
1888                 }
1889
1890                 assert(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
1891
1892                 if (argpar_item->type == ARGPAR_ITEM_TYPE_NON_OPT) {
1893                         const struct argpar_item_non_opt *item_non_opt =
1894                                         (const struct argpar_item_non_opt *)
1895                                                         argpar_item;
1896
1897                         ERR("Unexpected argument `%s`.", item_non_opt->arg);
1898                         goto error;
1899                 }
1900
1901                 item_opt = (const struct argpar_item_opt *) argpar_item;
1902
1903                 ingested_args = argpar_state_get_ingested_orig_args(
1904                                 argpar_state);
1905
1906                 my_argc -= ingested_args;
1907                 my_argv += ingested_args;
1908
1909                 switch (item_opt->descr->id) {
1910                 case OPT_HELP:
1911                         SHOW_HELP();
1912                         ret = 0;
1913                         goto end;
1914                 case OPT_LIST_OPTIONS:
1915                         list_cmd_options_argpar(stdout, add_trigger_options);
1916                         ret = 0;
1917                         goto end;
1918                 case OPT_CONDITION:
1919                 {
1920                         if (condition) {
1921                                 ERR("A --condition was already given.");
1922                                 goto error;
1923                         }
1924
1925                         condition = parse_condition(&my_argc, &my_argv);
1926                         if (!condition) {
1927                                 /*
1928                                  * An error message was already printed by
1929                                  * parse_condition.
1930                                  */
1931                                 goto error;
1932                         }
1933
1934                         break;
1935                 }
1936                 case OPT_ACTION:
1937                 {
1938                         action = parse_action(&my_argc, &my_argv);
1939                         if (!action) {
1940                                 /*
1941                                  * An error message was already printed by
1942                                  * parse_condition.
1943                                  */
1944                                 goto error;
1945                         }
1946
1947                         ret = lttng_dynamic_pointer_array_add_pointer(
1948                                         &actions, action);
1949                         if (ret) {
1950                                 ERR("Failed to add pointer to pointer array.");
1951                                 goto error;
1952                         }
1953
1954                         /* Ownership of the action was transferred to the group. */
1955                         action = NULL;
1956
1957                         break;
1958                 }
1959                 case OPT_ID:
1960                 {
1961                         if (!assign_string(&id, item_opt->arg, "--id")) {
1962                                 goto error;
1963                         }
1964
1965                         break;
1966                 }
1967                 case OPT_FIRE_ONCE_AFTER:
1968                 {
1969                         if (!assign_string(&fire_once_after_str, item_opt->arg,
1970                                         "--fire-once-after")) {
1971                                 goto error;
1972                         }
1973
1974                         break;
1975                 }
1976                 case OPT_FIRE_EVERY:
1977                 {
1978                         if (!assign_string(&fire_every_str, item_opt->arg,
1979                                         "--fire-every")) {
1980                                 goto error;
1981                         }
1982
1983                         break;
1984                 }
1985                 case OPT_USER_ID:
1986                 {
1987                         if (!assign_string(&user_id, item_opt->arg,
1988                                         "--user-id")) {
1989                                 goto error;
1990                         }
1991
1992                         break;
1993                 }
1994                 default:
1995                         abort();
1996                 }
1997         }
1998
1999         if (!condition) {
2000                 ERR("Missing --condition.");
2001                 goto error;
2002         }
2003
2004         if (lttng_dynamic_pointer_array_get_count(&actions) == 0) {
2005                 ERR("Need at least one --action.");
2006                 goto error;
2007         }
2008
2009         if (fire_every_str && fire_once_after_str) {
2010                 ERR("Can't specify both --fire-once-after and --fire-every.");
2011                 goto error;
2012         }
2013
2014         action_group = lttng_action_group_create();
2015         if (!action_group) {
2016                 goto error;
2017         }
2018
2019         for (i = 0; i < lttng_dynamic_pointer_array_get_count(&actions); i++) {
2020                 enum lttng_action_status status;
2021
2022                 action = lttng_dynamic_pointer_array_steal_pointer(&actions, i);
2023
2024                 status = lttng_action_group_add_action(action_group, action);
2025                 if (status != LTTNG_ACTION_STATUS_OK) {
2026                         goto error;
2027                 }
2028
2029                 /*
2030                  * The `lttng_action_group_add_action()` takes a reference to
2031                  * the action. We can destroy ours.
2032                  */
2033                 lttng_action_destroy(action);
2034                 action = NULL;
2035         }
2036
2037         trigger = lttng_trigger_create(condition, action_group);
2038         if (!trigger) {
2039                 goto error;
2040         }
2041
2042         if (id) {
2043                 enum lttng_trigger_status trigger_status =
2044                                 lttng_trigger_set_name(trigger, id);
2045
2046                 if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
2047                         ERR("Failed to set trigger id.");
2048                         goto error;
2049                 }
2050         }
2051
2052         if (fire_once_after_str) {
2053                 unsigned long long threshold;
2054                 enum lttng_trigger_status trigger_status;
2055
2056                 if (utils_parse_unsigned_long_long(fire_once_after_str, &threshold) != 0) {
2057                         ERR("Failed to parse `%s` as an integer.", fire_once_after_str);
2058                         goto error;
2059                 }
2060
2061                 trigger_status = lttng_trigger_set_firing_policy(trigger,
2062                                 LTTNG_TRIGGER_FIRING_POLICY_ONCE_AFTER_N,
2063                                 threshold);
2064                 if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
2065                         ERR("Failed to set trigger's policy to `fire once after N`.");
2066                         goto error;
2067                 }
2068         }
2069
2070         if (fire_every_str) {
2071                 unsigned long long threshold;
2072                 enum lttng_trigger_status trigger_status;
2073
2074                 if (utils_parse_unsigned_long_long(fire_every_str, &threshold) != 0) {
2075                         ERR("Failed to parse `%s` as an integer.", fire_every_str);
2076                         goto error;
2077                 }
2078
2079                 trigger_status = lttng_trigger_set_firing_policy(trigger,
2080                                 LTTNG_TRIGGER_FIRING_POLICY_EVERY_N, threshold);
2081                 if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
2082                         ERR("Failed to set trigger's policy to `fire every N`.");
2083                         goto error;
2084                 }
2085         }
2086
2087         if (user_id) {
2088                 enum lttng_trigger_status trigger_status;
2089                 char *end;
2090                 long long uid;
2091
2092                 errno = 0;
2093                 uid = strtol(user_id, &end, 10);
2094                 if (end == user_id || *end != '\0' || errno != 0) {
2095                         ERR("Failed to parse `%s` as a user id.", user_id);
2096                 }
2097
2098                 trigger_status = lttng_trigger_set_owner_uid(trigger, uid);
2099                 if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
2100                         ERR("Failed to set trigger's user identity.");
2101                         goto error;
2102                 }
2103         }
2104
2105         ret = lttng_register_trigger(trigger);
2106         if (ret) {
2107                 ERR("Failed to register trigger: %s.", lttng_strerror(ret));
2108                 goto error;
2109         }
2110
2111         MSG("Trigger registered successfully.");
2112
2113         goto end;
2114
2115 error:
2116         ret = 1;
2117
2118 end:
2119         argpar_state_destroy(argpar_state);
2120         argpar_item_destroy(argpar_item);
2121         lttng_dynamic_pointer_array_reset(&actions);
2122         lttng_condition_destroy(condition);
2123         lttng_action_destroy(action_group);
2124         lttng_action_destroy(action);
2125         lttng_trigger_destroy(trigger);
2126         free(error);
2127         free(id);
2128         free(fire_once_after_str);
2129         free(fire_every_str);
2130         free(user_id);
2131         return ret;
2132 }