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