*
*/
-#include <ctype.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-
#include "../command.hpp"
#include "../loglevel.hpp"
#include "../uprobe.hpp"
-
-#include "common/argpar/argpar.h"
#include "common/argpar-utils/argpar-utils.hpp"
+#include "common/argpar/argpar.h"
#include "common/dynamic-array.hpp"
#include "common/mi-lttng.hpp"
#include "common/string-utils/string-utils.hpp"
#include "common/utils.hpp"
+
#include <lttng/domain-internal.hpp>
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
/* For lttng_event_rule_type_str(). */
-#include <lttng/event-rule/event-rule-internal.hpp>
-#include <lttng/lttng.h>
+#include "common/dynamic-array.hpp"
#include "common/filter/filter-ast.hpp"
#include "common/filter/filter-ir.hpp"
-#include "common/dynamic-array.hpp"
+
+#include <lttng/event-rule/event-rule-internal.hpp>
+#include <lttng/lttng.h>
#if (LTTNG_SYMBOL_NAME_LEN == 256)
#define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
#ifdef LTTNG_EMBED_HELP
static const char help_msg[] =
#include <lttng-add-trigger.1.h>
-;
+ ;
#endif
enum {
ARGPAR_OPT_DESCR_SENTINEL
};
-static
-bool has_syscall_prefix(const char *arg)
+static bool has_syscall_prefix(const char *arg)
{
bool matches = false;
const char kernel_syscall_type_opt_prefix[] = "kernel:syscall";
const size_t kernel_syscall_type_opt_prefix_len =
- sizeof(kernel_syscall_type_opt_prefix) - 1;
+ sizeof(kernel_syscall_type_opt_prefix) - 1;
const char syscall_type_opt_prefix[] = "syscall";
- const size_t syscall_type_opt_prefix_len =
- sizeof(syscall_type_opt_prefix) - 1;
+ const size_t syscall_type_opt_prefix_len = sizeof(syscall_type_opt_prefix) - 1;
- if (strncmp(arg, syscall_type_opt_prefix,
- syscall_type_opt_prefix_len) == 0) {
+ if (strncmp(arg, syscall_type_opt_prefix, syscall_type_opt_prefix_len) == 0) {
matches = true;
- } else if (strncmp(arg, kernel_syscall_type_opt_prefix,
- kernel_syscall_type_opt_prefix_len) == 0) {
+ } else if (strncmp(arg,
+ kernel_syscall_type_opt_prefix,
+ kernel_syscall_type_opt_prefix_len) == 0) {
matches = true;
} else {
matches = false;
return matches;
}
-static
-bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg)
+static bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg)
{
bool ret;
if (strcmp(arg, "user") == 0 || strcmp(arg, "user:tracepoint") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT;
- } else if (strcmp(arg, "kernel") == 0 ||
- strcmp(arg, "kernel:tracepoint") == 0) {
+ } else if (strcmp(arg, "kernel") == 0 || strcmp(arg, "kernel:tracepoint") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT;
} else if (strcmp(arg, "jul") == 0 || strcmp(arg, "jul:logging") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_JUL_LOGGING;
- } else if (strcmp(arg, "log4j") == 0 ||
- strcmp(arg, "log4j:logging") == 0) {
+ } else if (strcmp(arg, "log4j") == 0 || strcmp(arg, "log4j:logging") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING;
- } else if (strcmp(arg, "python") == 0 ||
- strcmp(arg, "python:logging") == 0) {
+ } else if (strcmp(arg, "python") == 0 || strcmp(arg, "python:logging") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING;
- } else if (strcmp(arg, "kprobe") == 0 ||
- strcmp(arg, "kernel:kprobe") == 0) {
+ } else if (strcmp(arg, "kprobe") == 0 || strcmp(arg, "kernel:kprobe") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE;
} else if (strcmp(arg, "kernel:uprobe") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE;
return ret;
}
-static
-bool assign_string(char **dest, const char *src, const char *opt_name)
+static bool assign_string(char **dest, const char *src, const char *opt_name)
{
bool ret;
return ret;
}
-static bool parse_syscall_emission_site_from_type(const char *str,
- enum lttng_event_rule_kernel_syscall_emission_site *type)
+static bool
+parse_syscall_emission_site_from_type(const char *str,
+ enum lttng_event_rule_kernel_syscall_emission_site *type)
{
bool ret = false;
const char kernel_prefix[] = "kernel:";
str = &str[kernel_prefix_len];
}
- if (strcmp(str, "syscall") == 0 ||
- strcmp(str, "syscall:entry+exit") == 0) {
+ if (strcmp(str, "syscall") == 0 || strcmp(str, "syscall:entry+exit") == 0) {
*type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT;
} else if (strcmp(str, "syscall:entry") == 0) {
*type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY;
* Return true if the string was successfully parsed as a log level string.
*/
static bool parse_log_level_string(const char *str,
- enum lttng_event_rule_type event_rule_type,
- int *log_level,
- bool *log_level_only)
+ enum lttng_event_rule_type event_rule_type,
+ int *log_level,
+ bool *log_level_only)
{
bool ret;
case LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT:
{
enum lttng_loglevel log_level_min, log_level_max;
- if (!loglevel_parse_range_string(
- str, &log_level_min, &log_level_max)) {
+ if (!loglevel_parse_range_string(str, &log_level_min, &log_level_max)) {
goto error;
}
/* Only support VAL and VAL.. for now. */
- if (log_level_min != log_level_max &&
- log_level_max != LTTNG_LOGLEVEL_EMERG) {
+ if (log_level_min != log_level_max && log_level_max != LTTNG_LOGLEVEL_EMERG) {
goto error;
}
case LTTNG_EVENT_RULE_TYPE_LOG4J_LOGGING:
{
enum lttng_loglevel_log4j log_level_min, log_level_max;
- if (!loglevel_log4j_parse_range_string(
- str, &log_level_min, &log_level_max)) {
+ if (!loglevel_log4j_parse_range_string(str, &log_level_min, &log_level_max)) {
goto error;
}
/* Only support VAL and VAL.. for now. */
- if (log_level_min != log_level_max &&
- log_level_max != LTTNG_LOGLEVEL_LOG4J_FATAL) {
+ if (log_level_min != log_level_max && log_level_max != LTTNG_LOGLEVEL_LOG4J_FATAL) {
goto error;
}
case LTTNG_EVENT_RULE_TYPE_JUL_LOGGING:
{
enum lttng_loglevel_jul log_level_min, log_level_max;
- if (!loglevel_jul_parse_range_string(
- str, &log_level_min, &log_level_max)) {
+ if (!loglevel_jul_parse_range_string(str, &log_level_min, &log_level_max)) {
goto error;
}
/* Only support VAL and VAL.. for now. */
- if (log_level_min != log_level_max &&
- log_level_max != LTTNG_LOGLEVEL_JUL_SEVERE) {
+ if (log_level_min != log_level_max && log_level_max != LTTNG_LOGLEVEL_JUL_SEVERE) {
goto error;
}
case LTTNG_EVENT_RULE_TYPE_PYTHON_LOGGING:
{
enum lttng_loglevel_python log_level_min, log_level_max;
- if (!loglevel_python_parse_range_string(
- str, &log_level_min, &log_level_max)) {
+ if (!loglevel_python_parse_range_string(str, &log_level_min, &log_level_max)) {
goto error;
}
/* Only support VAL and VAL.. for now. */
if (log_level_min != log_level_max &&
- log_level_max !=
- LTTNG_LOGLEVEL_PYTHON_CRITICAL) {
+ log_level_max != LTTNG_LOGLEVEL_PYTHON_CRITICAL) {
goto error;
}
}
static int parse_kernel_probe_opts(const char *source,
- struct lttng_kernel_probe_location **location)
+ struct lttng_kernel_probe_location **location)
{
int ret = 0;
int match;
uint64_t offset;
/* Check for symbol+offset. */
- match = sscanf(source,
- "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
- "[^'+']+%18s",
- name, s_hex);
+ match = sscanf(
+ source, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "[^'+']+%18s", name, s_hex);
if (match == 2) {
if (*s_hex == '\0') {
ERR("Kernel probe symbol offset is missing.");
}
offset = strtoull(s_hex, NULL, 0);
- *location = lttng_kernel_probe_location_symbol_create(
- symbol_name, offset);
+ *location = lttng_kernel_probe_location_symbol_create(symbol_name, offset);
if (!*location) {
ERR("Failed to create symbol kernel probe location.");
goto error;
/* Check for symbol. */
if (isalpha(name[0]) || name[0] == '_') {
- match = sscanf(source,
- "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API
- "s",
- name);
+ match = sscanf(source, "%" LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "s", name);
if (match == 1) {
symbol_name = strndup(name, LTTNG_SYMBOL_NAME_LEN);
if (!symbol_name) {
goto error;
}
- *location = lttng_kernel_probe_location_symbol_create(
- symbol_name, 0);
+ *location = lttng_kernel_probe_location_symbol_create(symbol_name, 0);
if (!*location) {
ERR("Failed to create symbol kernel probe location.");
goto error;
return ret;
}
-static
-struct lttng_event_expr *ir_op_load_expr_to_event_expr(
- const struct ir_load_expression *load_expr,
- const char *capture_str)
+static struct lttng_event_expr *
+ir_op_load_expr_to_event_expr(const struct ir_load_expression *load_expr, const char *capture_str)
{
char *provider_name = NULL;
struct lttng_event_expr *event_expr = NULL;
const struct ir_load_expression_op *load_expr_op = load_expr->child;
- const enum ir_load_expression_type load_expr_child_type =
- load_expr_op->type;
+ const enum ir_load_expression_type load_expr_child_type = load_expr_op->type;
switch (load_expr_child_type) {
case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
LTTNG_ASSERT(field_name);
event_expr = load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ?
- lttng_event_expr_event_payload_field_create(field_name) :
- lttng_event_expr_channel_context_field_create(field_name);
+ lttng_event_expr_event_payload_field_create(field_name) :
+ lttng_event_expr_channel_context_field_create(field_name);
if (!event_expr) {
ERR("Failed to create %s event expression: field name = `%s`.",
- load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ?
- "payload field" : "channel context",
- field_name);
+ load_expr_child_type == IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT ?
+ "payload field" :
+ "channel context",
+ field_name);
goto error;
}
colon = strchr(field_name, ':');
if (!colon) {
ERR("Invalid app-specific context field name: missing colon in `%s`.",
- field_name);
+ field_name);
goto error;
}
type_name = colon + 1;
if (*type_name == '\0') {
ERR("Invalid app-specific context field name: missing type name after colon in `%s`.",
- field_name);
+ field_name);
goto error;
}
goto error;
}
- event_expr = lttng_event_expr_app_specific_context_field_create(
- provider_name, type_name);
+ event_expr = lttng_event_expr_app_specific_context_field_create(provider_name,
+ type_name);
if (!event_expr) {
ERR("Failed to create app-specific context field event expression: provider name = `%s`, type name = `%s`",
- provider_name, type_name);
+ provider_name,
+ type_name);
goto error;
}
break;
}
default:
- ERR("%s: unexpected load expr type %d.", __func__,
- load_expr_op->type);
+ ERR("%s: unexpected load expr type %d.", __func__, load_expr_op->type);
abort();
}
break;
case IR_LOAD_EXPRESSION_GET_SYMBOL:
ERR("While parsing expression `%s`: Capturing subfields is not supported.",
- capture_str);
+ capture_str);
goto error;
default:
- ERR("%s: unexpected load expression operator %s.", __func__,
- ir_load_expression_type_str(load_expr_op->type));
+ ERR("%s: unexpected load expression operator %s.",
+ __func__,
+ ir_load_expression_type_str(load_expr_op->type));
abort();
}
return event_expr;
}
-static
-struct lttng_event_expr *ir_op_load_to_event_expr(
- const struct ir_op *ir, const char *capture_str)
+static struct lttng_event_expr *ir_op_load_to_event_expr(const struct ir_op *ir,
+ const char *capture_str)
{
struct lttng_event_expr *event_expr = NULL;
switch (ir->data_type) {
case IR_DATA_EXPRESSION:
{
- const struct ir_load_expression *ir_load_expr =
- ir->u.load.u.expression;
+ const struct ir_load_expression *ir_load_expr = ir->u.load.u.expression;
- event_expr = ir_op_load_expr_to_event_expr(
- ir_load_expr, capture_str);
+ event_expr = ir_op_load_expr_to_event_expr(ir_load_expr, capture_str);
break;
}
default:
- ERR("%s: unexpected data type: %s.", __func__,
- ir_data_type_str(ir->data_type));
+ ERR("%s: unexpected data type: %s.", __func__, ir_data_type_str(ir->data_type));
abort();
}
return event_expr;
}
-static
-const char *ir_operator_type_human_str(enum ir_op_type op)
+static const char *ir_operator_type_human_str(enum ir_op_type op)
{
const char *name;
return name;
}
-static
-struct lttng_event_expr *ir_op_root_to_event_expr(const struct ir_op *ir,
- const char *capture_str)
+static struct lttng_event_expr *ir_op_root_to_event_expr(const struct ir_op *ir,
+ const char *capture_str)
{
struct lttng_event_expr *event_expr = NULL;
case IR_OP_UNARY:
case IR_OP_LOGICAL:
ERR("While parsing expression `%s`: %s operators are not allowed in capture expressions.",
- capture_str,
- ir_operator_type_human_str(ir->op));
+ capture_str,
+ ir_operator_type_human_str(ir->op));
break;
default:
- ERR("%s: unexpected IR op type: %s.", __func__,
- ir_op_type_str(ir->op));
+ ERR("%s: unexpected IR op type: %s.", __func__, ir_op_type_str(ir->op));
abort();
}
return event_expr;
}
-static
-void destroy_event_expr(void *ptr)
+static void destroy_event_expr(void *ptr)
{
lttng_event_expr_destroy((lttng_event_expr *) ptr);
}
};
} /* namespace */
-static
-struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv,
- int argc_offset)
+static struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv, int argc_offset)
{
- enum lttng_event_rule_type event_rule_type =
- LTTNG_EVENT_RULE_TYPE_UNKNOWN;
+ enum lttng_event_rule_type event_rule_type = LTTNG_EVENT_RULE_TYPE_UNKNOWN;
struct argpar_iter *argpar_iter = NULL;
const struct argpar_item *argpar_item = NULL;
int consumed_args = -1;
/* Log level. */
char *log_level_str = NULL;
- lttng_dynamic_pointer_array_init(&res.capture_descriptors,
- destroy_event_expr);
+ lttng_dynamic_pointer_array_init(&res.capture_descriptors, destroy_event_expr);
lttng_dynamic_pointer_array_init(&exclude_names, free);
while (true) {
enum parse_next_item_status status;
- status = parse_next_item(argpar_iter, &argpar_item,
- argc_offset, *argv, false, NULL, NULL);
+ status = parse_next_item(
+ argpar_iter, &argpar_item, argc_offset, *argv, false, NULL, NULL);
if (status == PARSE_NEXT_ITEM_STATUS_ERROR ||
- status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
+ status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
goto error;
} else if (status == PARSE_NEXT_ITEM_STATUS_END) {
break;
LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK);
if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) {
- const struct argpar_opt_descr *descr =
- argpar_item_opt_descr(argpar_item);
+ const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item);
const char *arg = argpar_item_opt_arg(argpar_item);
switch (descr->id) {
}
/* Save the string for later use. */
- if (!assign_string(&event_rule_type_str, arg,
- "--type/-t")) {
+ if (!assign_string(&event_rule_type_str, arg, "--type/-t")) {
goto error;
}
break;
case OPT_LOCATION:
- if (!assign_string(&location, arg,
- "--location/-L")) {
+ if (!assign_string(&location, arg, "--location/-L")) {
goto error;
}
break;
case OPT_EVENT_NAME:
- if (!assign_string(&event_name, arg,
- "--event-name/-E")) {
+ if (!assign_string(&event_name, arg, "--event-name/-E")) {
goto error;
}
break;
case OPT_FILTER:
- if (!assign_string(&filter, arg,
- "--filter/-f")) {
+ if (!assign_string(&filter, arg, "--filter/-f")) {
goto error;
}
break;
case OPT_NAME:
- if (!assign_string(&name, arg,
- "--name/-n")) {
+ if (!assign_string(&name, arg, "--name/-n")) {
goto error;
}
{
int ret;
- ret = lttng_dynamic_pointer_array_add_pointer(
- &exclude_names,
- strdup(arg));
+ ret = lttng_dynamic_pointer_array_add_pointer(&exclude_names,
+ strdup(arg));
if (ret != 0) {
ERR("Failed to add pointer to dynamic pointer array.");
goto error;
break;
}
case OPT_LOG_LEVEL:
- if (!assign_string(&log_level_str, arg,
- "--log-level/-l")) {
+ if (!assign_string(&log_level_str, arg, "--log-level/-l")) {
goto error;
}
{
int ret;
- ret = filter_parser_ctx_create_from_filter_expression(
- arg, &parser_ctx);
+ ret = filter_parser_ctx_create_from_filter_expression(arg,
+ &parser_ctx);
if (ret) {
ERR("Failed to parse capture expression `%s`.", arg);
goto error;
}
- event_expr = ir_op_root_to_event_expr(
- parser_ctx->ir_root, arg);
+ event_expr = ir_op_root_to_event_expr(parser_ctx->ir_root, arg);
filter_parser_ctx_free(parser_ctx);
parser_ctx = nullptr;
if (!event_expr) {
}
ret = lttng_dynamic_pointer_array_add_pointer(
- &res.capture_descriptors,
- event_expr);
+ &res.capture_descriptors, event_expr);
if (ret) {
goto error;
}
default:
if (name) {
ERR("Can't use --name with %s event rules.",
- lttng_event_rule_type_str(
- event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) {
ERR("Can't use --exclude-name/-x with %s event rules.",
- lttng_event_rule_type_str(
- event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
}
case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
if (!location) {
ERR("Event rule of type %s requires a --location.",
- lttng_event_rule_type_str(event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
default:
if (location) {
ERR("Can't use --location with %s event rules.",
- lttng_event_rule_type_str(event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
if (event_name) {
ERR("Can't use --event-name with %s event rules.",
- lttng_event_rule_type_str(
- event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
}
break;
default:
ERR("Filter expressions are not supported for %s event rules.",
- lttng_event_rule_type_str(event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
}
if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) {
if (event_rule_type != LTTNG_EVENT_RULE_TYPE_USER_TRACEPOINT) {
ERR("Event name exclusions are not yet implemented for %s event rules.",
- lttng_event_rule_type_str(event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
break;
}
- if (!parse_log_level_string(log_level_str, event_rule_type,
- &log_level, &log_level_only)) {
- ERR("Failed to parse log level string `%s`.",
- log_level_str);
+ if (!parse_log_level_string(
+ log_level_str, event_rule_type, &log_level, &log_level_only)) {
+ ERR("Failed to parse log level string `%s`.", log_level_str);
goto error;
}
if (log_level_only) {
log_level_rule = lttng_log_level_rule_exactly_create(log_level);
} else {
- log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(log_level);
+ log_level_rule = lttng_log_level_rule_at_least_as_severe_as_create(
+ log_level);
}
if (log_level_rule == NULL) {
}
default:
ERR("Log levels are not supported for %s event rules.",
- lttng_event_rule_type_str(event_rule_type));
+ lttng_event_rule_type_str(event_rule_type));
goto error;
}
}
}
/* Set pattern. */
- event_rule_status = lttng_event_rule_user_tracepoint_set_name_pattern(
- res.er, name);
+ event_rule_status = lttng_event_rule_user_tracepoint_set_name_pattern(res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set user_tracepoint event rule's pattern to '%s'.",
- name);
+ ERR("Failed to set user_tracepoint event rule's pattern to '%s'.", name);
goto error;
}
/* Set filter. */
if (filter) {
- event_rule_status = lttng_event_rule_user_tracepoint_set_filter(
- res.er, filter);
+ event_rule_status =
+ lttng_event_rule_user_tracepoint_set_filter(res.er, filter);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set user_tracepoint event rule's filter to '%s'.",
- filter);
+ filter);
goto error;
}
}
/* Set exclusion list. */
if (lttng_dynamic_pointer_array_get_count(&exclude_names) > 0) {
int n;
- int count = lttng_dynamic_pointer_array_get_count(
- &exclude_names);
+ int count = lttng_dynamic_pointer_array_get_count(&exclude_names);
for (n = 0; n < count; n++) {
const char *exclude_name =
- (const char *) lttng_dynamic_pointer_array_get_pointer(
- &exclude_names,
- n);
+ (const char *) lttng_dynamic_pointer_array_get_pointer(
+ &exclude_names, n);
event_rule_status =
- lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
- res.er,
- exclude_name);
- if (event_rule_status !=
- LTTNG_EVENT_RULE_STATUS_OK) {
+ lttng_event_rule_user_tracepoint_add_name_pattern_exclusion(
+ res.er, exclude_name);
+ if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set user_tracepoint exclusion list element '%s'",
- exclude_name);
+ exclude_name);
goto error;
}
}
}
if (log_level_rule) {
- event_rule_status =
- lttng_event_rule_user_tracepoint_set_log_level_rule(
- res.er, log_level_rule);
+ event_rule_status = lttng_event_rule_user_tracepoint_set_log_level_rule(
+ res.er, log_level_rule);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set log level on event fule.");
}
/* Set pattern. */
- event_rule_status = lttng_event_rule_kernel_tracepoint_set_name_pattern(
- res.er, name);
+ event_rule_status =
+ lttng_event_rule_kernel_tracepoint_set_name_pattern(res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set kernel_tracepoint event rule's pattern to '%s'.",
- name);
+ ERR("Failed to set kernel_tracepoint event rule's pattern to '%s'.", name);
goto error;
}
/* Set filter. */
if (filter) {
- event_rule_status = lttng_event_rule_kernel_tracepoint_set_filter(
- res.er, filter);
+ event_rule_status =
+ lttng_event_rule_kernel_tracepoint_set_filter(res.er, filter);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set kernel_tracepoint event rule's filter to '%s'.",
- filter);
+ filter);
goto error;
}
}
}
/* Set pattern. */
- event_rule_status = lttng_event_rule_jul_logging_set_name_pattern(
- res.er, name);
+ event_rule_status = lttng_event_rule_jul_logging_set_name_pattern(res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set jul_logging event rule's pattern to '%s'.",
- name);
+ ERR("Failed to set jul_logging event rule's pattern to '%s'.", name);
goto error;
}
/* Set filter. */
if (filter) {
- event_rule_status = lttng_event_rule_jul_logging_set_filter(
- res.er, filter);
+ event_rule_status = lttng_event_rule_jul_logging_set_filter(res.er, filter);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set jul_logging event rule's filter to '%s'.",
- filter);
+ filter);
goto error;
}
}
if (log_level_rule) {
- event_rule_status =
- lttng_event_rule_jul_logging_set_log_level_rule(
- res.er, log_level_rule);
+ event_rule_status = lttng_event_rule_jul_logging_set_log_level_rule(
+ res.er, log_level_rule);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set log level on event fule.");
}
/* Set pattern. */
- event_rule_status = lttng_event_rule_log4j_logging_set_name_pattern(
- res.er, name);
+ event_rule_status = lttng_event_rule_log4j_logging_set_name_pattern(res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set jul_logging event rule's pattern to '%s'.",
- name);
+ ERR("Failed to set jul_logging event rule's pattern to '%s'.", name);
goto error;
}
/* Set filter. */
if (filter) {
- event_rule_status = lttng_event_rule_log4j_logging_set_filter(
- res.er, filter);
+ event_rule_status =
+ lttng_event_rule_log4j_logging_set_filter(res.er, filter);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set jul_logging event rule's filter to '%s'.",
- filter);
+ filter);
goto error;
}
}
if (log_level_rule) {
- event_rule_status =
- lttng_event_rule_log4j_logging_set_log_level_rule(
- res.er, log_level_rule);
+ event_rule_status = lttng_event_rule_log4j_logging_set_log_level_rule(
+ res.er, log_level_rule);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set log level on event fule.");
}
/* Set pattern. */
- event_rule_status = lttng_event_rule_python_logging_set_name_pattern(
- res.er, name);
+ event_rule_status = lttng_event_rule_python_logging_set_name_pattern(res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set jul_logging event rule's pattern to '%s'.",
- name);
+ ERR("Failed to set jul_logging event rule's pattern to '%s'.", name);
goto error;
}
/* Set filter. */
if (filter) {
- event_rule_status = lttng_event_rule_python_logging_set_filter(
- res.er, filter);
+ event_rule_status =
+ lttng_event_rule_python_logging_set_filter(res.er, filter);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set jul_logging event rule's filter to '%s'.",
- filter);
+ filter);
goto error;
}
}
if (log_level_rule) {
- event_rule_status =
- lttng_event_rule_python_logging_set_log_level_rule(
- res.er, log_level_rule);
+ event_rule_status = lttng_event_rule_python_logging_set_log_level_rule(
+ res.er, log_level_rule);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set log level on event fule.");
int ret;
enum lttng_event_rule_status event_rule_status;
- ret = parse_kernel_probe_opts(
- location, &kernel_probe_location);
+ ret = parse_kernel_probe_opts(location, &kernel_probe_location);
if (ret) {
ERR("Failed to parse kernel probe location.");
goto error;
}
event_rule_status =
- lttng_event_rule_kernel_kprobe_set_event_name(
- res.er, event_name);
+ lttng_event_rule_kernel_kprobe_set_event_name(res.er, event_name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set kprobe event rule's name to '%s'.",
- event_name);
+ ERR("Failed to set kprobe event rule's name to '%s'.", event_name);
goto error;
}
int ret;
enum lttng_event_rule_status event_rule_status;
- ret = parse_userspace_probe_opts(
- location, &userspace_probe_location);
+ ret = parse_userspace_probe_opts(location, &userspace_probe_location);
if (ret) {
ERR("Failed to parse user space probe location.");
goto error;
}
event_rule_status =
- lttng_event_rule_kernel_uprobe_set_event_name(
- res.er, event_name);
+ lttng_event_rule_kernel_uprobe_set_event_name(res.er, event_name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set user space probe event rule's name to '%s'.",
- event_name);
+ event_name);
goto error;
}
enum lttng_event_rule_status event_rule_status;
enum lttng_event_rule_kernel_syscall_emission_site emission_site;
- if (!parse_syscall_emission_site_from_type(
- event_rule_type_str, &emission_site)) {
+ if (!parse_syscall_emission_site_from_type(event_rule_type_str, &emission_site)) {
ERR("Failed to parse syscall type '%s'.", event_rule_type_str);
goto error;
}
goto error;
}
- event_rule_status = lttng_event_rule_kernel_syscall_set_name_pattern(
- res.er, name);
+ event_rule_status = lttng_event_rule_kernel_syscall_set_name_pattern(res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set syscall event rule's pattern to '%s'.",
- name);
+ ERR("Failed to set syscall event rule's pattern to '%s'.", name);
goto error;
}
if (filter) {
- event_rule_status = lttng_event_rule_kernel_syscall_set_filter(
- res.er, filter);
+ event_rule_status =
+ lttng_event_rule_kernel_syscall_set_filter(res.er, filter);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
- ERR("Failed to set syscall event rule's filter to '%s'.",
- filter);
+ ERR("Failed to set syscall event rule's filter to '%s'.", filter);
goto error;
}
}
return res;
}
-static
-struct lttng_condition *handle_condition_event(int *argc, const char ***argv,
- int argc_offset)
+static struct lttng_condition *
+handle_condition_event(int *argc, const char ***argv, int argc_offset)
{
struct parse_event_rule_res res;
struct lttng_condition *c;
goto error;
}
- for (i = 0; i < lttng_dynamic_pointer_array_get_count(&res.capture_descriptors);
- i++) {
+ for (i = 0; i < lttng_dynamic_pointer_array_get_count(&res.capture_descriptors); i++) {
enum lttng_condition_status status;
struct lttng_event_expr **expr =
- (lttng_event_expr **) lttng_dynamic_array_get_element(
- &res.capture_descriptors.array, i);
+ (lttng_event_expr **) lttng_dynamic_array_get_element(
+ &res.capture_descriptors.array, i);
LTTNG_ASSERT(expr);
LTTNG_ASSERT(*expr);
- status = lttng_condition_event_rule_matches_append_capture_descriptor(
- c, *expr);
+ status = lttng_condition_event_rule_matches_append_capture_descriptor(c, *expr);
if (status != LTTNG_CONDITION_STATUS_OK) {
if (status == LTTNG_CONDITION_STATUS_UNSUPPORTED) {
ERR("The capture feature is unsupported by the event-rule condition type");
namespace {
struct condition_descr {
const char *name;
- struct lttng_condition *(*handler) (int *argc, const char ***argv,
- int argc_offset);
+ struct lttng_condition *(*handler)(int *argc, const char ***argv, int argc_offset);
};
} /* namespace */
-static const
-struct condition_descr condition_descrs[] = {
+static const struct condition_descr condition_descrs[] = {
{ "event-rule-matches", handle_condition_event },
};
-static
-void print_valid_condition_names(void)
+static void print_valid_condition_names(void)
{
unsigned int i;
}
}
-static
-struct lttng_condition *parse_condition(const char *condition_name, int *argc,
- const char ***argv, int argc_offset, int orig_arg_index,
- const char *orig_arg)
+static struct lttng_condition *parse_condition(const char *condition_name,
+ int *argc,
+ const char ***argv,
+ int argc_offset,
+ int orig_arg_index,
+ const char *orig_arg)
{
int i;
struct lttng_condition *cond;
if (!descr) {
ERR(WHILE_PARSING_ARG_N_ARG_FMT "Unknown condition name '%s'",
- orig_arg_index + 1, orig_arg, condition_name);
+ orig_arg_index + 1,
+ orig_arg,
+ condition_name);
print_valid_condition_names();
goto error;
}
/* Parse the value. */
if (utils_parse_unsigned_long_long(policy_value_str, &value) != 0) {
- ERR("Failed to parse rate policy value `%s` as an integer.",
- policy_value_str);
+ ERR("Failed to parse rate policy value `%s` as an integer.", policy_value_str);
goto end;
}
}
static const struct argpar_opt_descr notify_action_opt_descrs[] = {
- { OPT_RATE_POLICY, '\0', "rate-policy", true },
- ARGPAR_OPT_DESCR_SENTINEL
+ { OPT_RATE_POLICY, '\0', "rate-policy", true }, ARGPAR_OPT_DESCR_SENTINEL
};
-static
-struct lttng_action *handle_action_notify(int *argc, const char ***argv,
- int argc_offset)
+static struct lttng_action *handle_action_notify(int *argc, const char ***argv, int argc_offset)
{
struct lttng_action *action = NULL;
struct argpar_iter *argpar_iter = NULL;
while (true) {
enum parse_next_item_status status;
- status = parse_next_item(argpar_iter, &argpar_item,
- argc_offset, *argv, false, NULL,
- "While parsing `notify` action:");
+ status = parse_next_item(argpar_iter,
+ &argpar_item,
+ argc_offset,
+ *argv,
+ false,
+ NULL,
+ "While parsing `notify` action:");
if (status == PARSE_NEXT_ITEM_STATUS_ERROR ||
- status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
+ status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
goto error;
} else if (status == PARSE_NEXT_ITEM_STATUS_END) {
break;
LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK);
if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) {
- const struct argpar_opt_descr *descr =
- argpar_item_opt_descr(argpar_item);
+ const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item);
const char *arg = argpar_item_opt_arg(argpar_item);
switch (descr->id) {
* optional rate policy.
*/
-static struct lttng_action *handle_action_simple_session_with_policy(int *argc,
- const char ***argv,
- int argc_offset,
- struct lttng_action *(*create_action_cb)(void),
- enum lttng_action_status (*set_session_name_cb)(
- struct lttng_action *, const char *),
- enum lttng_action_status (*set_rate_policy_cb)(
- struct lttng_action *,
- const struct lttng_rate_policy *),
- const char *action_name)
+static struct lttng_action *handle_action_simple_session_with_policy(
+ int *argc,
+ const char ***argv,
+ int argc_offset,
+ struct lttng_action *(*create_action_cb)(void),
+ enum lttng_action_status (*set_session_name_cb)(struct lttng_action *, const char *),
+ enum lttng_action_status (*set_rate_policy_cb)(struct lttng_action *,
+ const struct lttng_rate_policy *),
+ const char *action_name)
{
struct lttng_action *action = NULL;
struct argpar_iter *argpar_iter = NULL;
LTTNG_ASSERT(set_rate_policy_cb);
const struct argpar_opt_descr rate_policy_opt_descrs[] = {
- { OPT_RATE_POLICY, '\0', "rate-policy", true },
- ARGPAR_OPT_DESCR_SENTINEL
+ { OPT_RATE_POLICY, '\0', "rate-policy", true }, ARGPAR_OPT_DESCR_SENTINEL
};
argpar_iter = argpar_iter_create(*argc, *argv, rate_policy_opt_descrs);
while (true) {
enum parse_next_item_status status;
- status = parse_next_item(argpar_iter, &argpar_item, argc_offset,
- *argv, false, NULL,
- "While parsing `%s` action:", action_name);
+ status = parse_next_item(argpar_iter,
+ &argpar_item,
+ argc_offset,
+ *argv,
+ false,
+ NULL,
+ "While parsing `%s` action:",
+ action_name);
if (status == PARSE_NEXT_ITEM_STATUS_ERROR ||
- status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
+ status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
goto error;
} else if (status == PARSE_NEXT_ITEM_STATUS_END) {
break;
LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK);
if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) {
- const struct argpar_opt_descr *descr =
- argpar_item_opt_descr(argpar_item);
+ const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item);
const char *arg = argpar_item_opt_arg(argpar_item);
switch (descr->id) {
action_status = set_session_name_cb(action, session_name_arg);
if (action_status != LTTNG_ACTION_STATUS_OK) {
ERR("Failed to set action %s session's session name to '%s'.",
- action_name, session_name_arg);
+ action_name,
+ session_name_arg);
goto error;
}
return action;
}
-static
-struct lttng_action *handle_action_start_session(int *argc,
- const char ***argv, int argc_offset)
+static struct lttng_action *
+handle_action_start_session(int *argc, const char ***argv, int argc_offset)
{
- return handle_action_simple_session_with_policy(argc, argv,
- argc_offset,
- lttng_action_start_session_create,
- lttng_action_start_session_set_session_name,
- lttng_action_start_session_set_rate_policy, "start");
+ return handle_action_simple_session_with_policy(argc,
+ argv,
+ argc_offset,
+ lttng_action_start_session_create,
+ lttng_action_start_session_set_session_name,
+ lttng_action_start_session_set_rate_policy,
+ "start");
}
-static
-struct lttng_action *handle_action_stop_session(int *argc,
- const char ***argv, int argc_offset)
+static struct lttng_action *
+handle_action_stop_session(int *argc, const char ***argv, int argc_offset)
{
- return handle_action_simple_session_with_policy(argc, argv,
- argc_offset,
- lttng_action_stop_session_create,
- lttng_action_stop_session_set_session_name,
- lttng_action_stop_session_set_rate_policy, "stop");
+ return handle_action_simple_session_with_policy(argc,
+ argv,
+ argc_offset,
+ lttng_action_stop_session_create,
+ lttng_action_stop_session_set_session_name,
+ lttng_action_stop_session_set_rate_policy,
+ "stop");
}
-static
-struct lttng_action *handle_action_rotate_session(int *argc,
- const char ***argv, int argc_offset)
+static struct lttng_action *
+handle_action_rotate_session(int *argc, const char ***argv, int argc_offset)
{
- return handle_action_simple_session_with_policy(argc, argv,
+ return handle_action_simple_session_with_policy(
+ argc,
+ argv,
argc_offset,
lttng_action_rotate_session_create,
lttng_action_rotate_session_set_session_name,
ARGPAR_OPT_DESCR_SENTINEL
};
-static
-struct lttng_action *handle_action_snapshot_session(int *argc,
- const char ***argv, int argc_offset)
+static struct lttng_action *
+handle_action_snapshot_session(int *argc, const char ***argv, int argc_offset)
{
struct lttng_action *action = NULL;
struct argpar_iter *argpar_iter = NULL;
while (true) {
enum parse_next_item_status status;
- status = parse_next_item(argpar_iter, &argpar_item, argc_offset,
- *argv, false, NULL, "While parsing `snapshot` action:");
+ status = parse_next_item(argpar_iter,
+ &argpar_item,
+ argc_offset,
+ *argv,
+ false,
+ NULL,
+ "While parsing `snapshot` action:");
if (status == PARSE_NEXT_ITEM_STATUS_ERROR ||
- status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
+ status == PARSE_NEXT_ITEM_STATUS_ERROR_MEMORY) {
goto error;
} else if (status == PARSE_NEXT_ITEM_STATUS_END) {
break;
LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK);
if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_OPT) {
- const struct argpar_opt_descr *descr =
- argpar_item_opt_descr(argpar_item);
+ const struct argpar_opt_descr *descr = argpar_item_opt_descr(argpar_item);
const char *arg = argpar_item_opt_arg(argpar_item);
switch (descr->id) {
goto error;
}
- action_status = lttng_action_snapshot_session_set_session_name(
- action, session_name_arg);
+ action_status = lttng_action_snapshot_session_set_session_name(action, session_name_arg);
if (action_status != LTTNG_ACTION_STATUS_OK) {
ERR("Failed to set action snapshot session's session name to '%s'.",
- session_name_arg);
+ session_name_arg);
goto error;
}
goto error;
}
- ret = lttng_snapshot_output_set_name(
- snapshot_name_arg, snapshot_output);
+ ret = lttng_snapshot_output_set_name(snapshot_name_arg, snapshot_output);
if (ret != 0) {
ERR("Failed to set name of snapshot output.");
goto error;
ret = lttng_snapshot_output_set_size(max_size, snapshot_output);
if (ret != 0) {
ERR("Failed to set snapshot output's max size to %" PRIu64 " bytes.",
- max_size);
+ max_size);
goto error;
}
}
}
if (uris[0].dtype == LTTNG_DST_PATH) {
- ret = lttng_snapshot_output_set_local_path(
- uris[0].dst.path, snapshot_output);
+ ret = lttng_snapshot_output_set_local_path(uris[0].dst.path,
+ snapshot_output);
free(uris);
if (ret != 0) {
- ERR("Failed to assign '%s' as a local destination.",
- url_arg);
+ ERR("Failed to assign '%s' as a local destination.", url_arg);
goto error;
}
} else {
- ret = lttng_snapshot_output_set_network_url(
- url_arg, snapshot_output);
+ ret = lttng_snapshot_output_set_network_url(url_arg, snapshot_output);
free(uris);
if (ret != 0) {
- ERR("Failed to assign '%s' as a network URL.",
- url_arg);
+ ERR("Failed to assign '%s' as a network URL.", url_arg);
goto error;
}
}
}
if (path_arg) {
- ret = lttng_snapshot_output_set_local_path(
- path_arg, snapshot_output);
+ ret = lttng_snapshot_output_set_local_path(path_arg, snapshot_output);
if (ret != 0) {
ERR("Failed to parse '%s' as a local path.", path_arg);
goto error;
* data URLs.
*/
ret = lttng_snapshot_output_set_network_urls(
- ctrl_url_arg, data_url_arg, snapshot_output);
+ ctrl_url_arg, data_url_arg, snapshot_output);
if (ret != 0) {
ERR("Failed to parse `%s` and `%s` as control and data URLs.",
- ctrl_url_arg, data_url_arg);
+ ctrl_url_arg,
+ data_url_arg);
goto error;
}
}
if (snapshot_output) {
- action_status = lttng_action_snapshot_session_set_output(
- action, snapshot_output);
+ action_status = lttng_action_snapshot_session_set_output(action, snapshot_output);
if (action_status != LTTNG_ACTION_STATUS_OK) {
ERR("Failed to set snapshot session action's output.");
goto error;
if (policy) {
enum lttng_action_status status;
- status = lttng_action_snapshot_session_set_rate_policy(
- action, policy);
+ status = lttng_action_snapshot_session_set_rate_policy(action, policy);
if (status != LTTNG_ACTION_STATUS_OK) {
ERR("Failed to set rate policy");
goto error;
namespace {
struct action_descr {
const char *name;
- struct lttng_action *(*handler) (int *argc, const char ***argv,
- int argc_offset);
+ struct lttng_action *(*handler)(int *argc, const char ***argv, int argc_offset);
};
} /* namespace */
-static const
-struct action_descr action_descrs[] = {
+static const struct action_descr action_descrs[] = {
{ "notify", handle_action_notify },
{ "start-session", handle_action_start_session },
{ "stop-session", handle_action_stop_session },
{ "snapshot-session", handle_action_snapshot_session },
};
-static
-void print_valid_action_names(void)
+static void print_valid_action_names(void)
{
unsigned int i;
}
}
-static
-struct lttng_action *parse_action(const char *action_name, int *argc,
- const char ***argv, int argc_offset, int orig_arg_index,
- const char *orig_arg)
+static struct lttng_action *parse_action(const char *action_name,
+ int *argc,
+ const char ***argv,
+ int argc_offset,
+ int orig_arg_index,
+ const char *orig_arg)
{
int i;
struct lttng_action *action;
if (!descr) {
ERR(WHILE_PARSING_ARG_N_ARG_FMT "Unknown action name '%s'",
- orig_arg_index + 1, orig_arg, action_name);
+ orig_arg_index + 1,
+ orig_arg,
+ action_name);
print_valid_action_names();
goto error;
}
return action;
}
-static const
-struct argpar_opt_descr add_trigger_options[] = {
+static const struct argpar_opt_descr add_trigger_options[] = {
{ OPT_HELP, 'h', "help", false },
{ OPT_LIST_OPTIONS, '\0', "list-options", false },
{ OPT_CONDITION, '\0', "condition", true },
ARGPAR_OPT_DESCR_SENTINEL,
};
-static
-void lttng_actions_destructor(void *p)
+static void lttng_actions_destructor(void *p)
{
struct lttng_action *action = (lttng_action *) p;
lttng_dynamic_pointer_array_init(&actions, lttng_actions_destructor);
if (lttng_opt_mi) {
- mi_writer = mi_lttng_writer_create(
- fileno(stdout), lttng_opt_mi);
+ mi_writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
if (!mi_writer) {
ret = CMD_ERROR;
goto error;
}
/* Open command element. */
- ret = mi_lttng_writer_command_open(mi_writer,
- mi_lttng_element_command_add_trigger);
+ ret = mi_lttng_writer_command_open(mi_writer, mi_lttng_element_command_add_trigger);
if (ret) {
ret = CMD_ERROR;
goto error;
}
/* Open output element. */
- ret = mi_lttng_writer_open_element(
- mi_writer, mi_lttng_element_command_output);
+ ret = mi_lttng_writer_open_element(mi_writer, mi_lttng_element_command_output);
if (ret) {
ret = CMD_ERROR;
goto error;
const char *arg;
argpar_iter_destroy(argpar_iter);
- argpar_iter = argpar_iter_create(my_argc, my_argv,
- add_trigger_options);
+ argpar_iter = argpar_iter_create(my_argc, my_argv, add_trigger_options);
if (!argpar_iter) {
ERR("Failed to create argpar iter.");
goto error;
}
- status = parse_next_item(argpar_iter, &argpar_item,
- argc - my_argc, my_argv, true, &argpar_error, NULL);
+ status = parse_next_item(argpar_iter,
+ &argpar_item,
+ argc - my_argc,
+ my_argv,
+ true,
+ &argpar_error,
+ NULL);
if (status == PARSE_NEXT_ITEM_STATUS_ERROR) {
-
- if (argpar_error_type(argpar_error) ==
- ARGPAR_ERROR_TYPE_MISSING_OPT_ARG) {
+ if (argpar_error_type(argpar_error) == ARGPAR_ERROR_TYPE_MISSING_OPT_ARG) {
int opt_id = argpar_error_opt_descr(argpar_error, NULL)->id;
if (opt_id == OPT_CONDITION) {
LTTNG_ASSERT(status == PARSE_NEXT_ITEM_STATUS_OK);
if (argpar_item_type(argpar_item) == ARGPAR_ITEM_TYPE_NON_OPT) {
- ERR("Unexpected argument `%s`.",
- argpar_item_non_opt_arg(argpar_item));
+ ERR("Unexpected argument `%s`.", argpar_item_non_opt_arg(argpar_item));
goto error;
}
goto error;
}
- condition = parse_condition(arg, &my_argc, &my_argv,
- argc - my_argc, argc - my_argc - ingested_args,
- my_argv[-ingested_args]);
+ condition = parse_condition(arg,
+ &my_argc,
+ &my_argv,
+ argc - my_argc,
+ argc - my_argc - ingested_args,
+ my_argv[-ingested_args]);
if (!condition) {
/*
* An error message was already printed by
}
case OPT_ACTION:
{
- action = parse_action(arg, &my_argc, &my_argv,
- argc - my_argc, argc - my_argc - ingested_args,
- my_argv[-ingested_args]);
+ action = parse_action(arg,
+ &my_argc,
+ &my_argv,
+ argc - my_argc,
+ argc - my_argc - ingested_args,
+ my_argv[-ingested_args]);
if (!action) {
/*
* An error message was already printed by
goto error;
}
- ret = lttng_dynamic_pointer_array_add_pointer(
- &actions, action);
+ ret = lttng_dynamic_pointer_array_add_pointer(&actions, action);
if (ret) {
ERR("Failed to add pointer to pointer array.");
goto error;
}
case OPT_OWNER_UID:
{
- if (!assign_string(&owner_uid, arg,
- "--owner-uid")) {
+ if (!assign_string(&owner_uid, arg, "--owner-uid")) {
goto error;
}
}
if (ret_code != LTTNG_OK) {
- ERR("Failed to register trigger: %s.",
- lttng_strerror(-ret_code));
+ ERR("Failed to register trigger: %s.", lttng_strerror(-ret_code));
goto error;
}
} else {
const char *returned_trigger_name;
const enum lttng_trigger_status trigger_status =
- lttng_trigger_get_name(trigger,
- &returned_trigger_name);
+ lttng_trigger_get_name(trigger, &returned_trigger_name);
if (trigger_status != LTTNG_TRIGGER_STATUS_OK) {
WARN("Failed to retrieve the added trigger's name.");
goto cleanup;
}
- mi_ret = mi_lttng_writer_write_element_bool(mi_writer,
- mi_lttng_element_command_success, ret ? 0 : 1);
+ mi_ret = mi_lttng_writer_write_element_bool(
+ mi_writer, mi_lttng_element_command_success, ret ? 0 : 1);
if (mi_ret) {
ret = 1;
goto cleanup;
projects / lttng-tools.git / blobdiff