if (strcmp(arg, "tracepoint") == 0 || strcmp(arg, "logging") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_TRACEPOINT;
} else if (strcmp(arg, "kprobe") == 0 ||
- strcmp(arg, "kernel-probe") == 0) {
- *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE;
- } else if (strcmp(arg, "uprobe") == 0 ||
- strcmp(arg, "userspace-probe") == 0) {
- *dest = LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE;
+ 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;
} else if (strcmp(arg, "function") == 0) {
*dest = LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION;
- } else if (strncmp(arg, "syscall", strlen("syscall")) == 0) {
+ } else if (strncmp(arg, "syscall", strlen("syscall")) == 0 ||
+ strncmp(arg, "kernel:syscall",
+ strlen("kernel:syscall")) == 0) {
/*
* Matches the following:
* - syscall
* - syscall:exit
* - syscall:entry+exit
* - syscall:*
+ * - kernel:syscall
+ * - kernel:syscall:entry
+ * - kernel:syscall:exit
+ * - kernel:syscall:entry+exit
+ * - kernel:syscall:*
*
* Validation for the right side is left to further usage sites.
*/
- *dest = LTTNG_EVENT_RULE_TYPE_SYSCALL;
+ *dest = LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL;
} else {
ERR("Invalid `--type` value: %s", arg);
goto error;
}
static bool parse_syscall_emission_site_from_type(const char *str,
- enum lttng_event_rule_syscall_emission_site_type *type)
+ enum lttng_event_rule_kernel_syscall_emission_site *type)
{
bool ret = false;
+ const char kernel_prefix[] = "kernel:";
+ const size_t kernel_prefix_len = sizeof(kernel_prefix) - 1;
+
+ /*
+ * If the passed string is of the form "kernel:syscall*", move the
+ * pointer passed "kernel:".
+ */
+ if (strncmp(str, kernel_prefix, kernel_prefix_len) == 0) {
+ str = &str[kernel_prefix_len];
+ }
+
if (strcmp(str, "syscall") == 0 ||
strcmp(str, "syscall:entry+exit") == 0) {
- *type = LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT;
+ *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT;
} else if (strcmp(str, "syscall:entry") == 0) {
- *type = LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY;
+ *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY;
} else if (strcmp(str, "syscall:exit") == 0) {
- *type = LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT;
+ *type = LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT;
} else {
goto error;
}
return ret;
}
-/* This is defined in enable_events.c. */
-LTTNG_HIDDEN
-int validate_exclusion_list(
- const char *event_name, const char *const *exclusions);
-
/*
* Parse `str` as a log level in domain `domain_type`.
*
*/
switch (event_rule_type) {
case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
- case LTTNG_EVENT_RULE_TYPE_SYSCALL:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
if (!name) {
name = strdup("*");
}
* If omitted, it defaults to the location.
*/
switch (event_rule_type) {
- case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE:
- case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION:
if (!location) {
ERR("Event rule of type %s requires a --location.",
/* Validate event rule type against domain. */
switch (event_rule_type) {
- case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION:
- case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE:
- case LTTNG_EVENT_RULE_TYPE_SYSCALL:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
if (domain_type != LTTNG_DOMAIN_KERNEL) {
ERR("Event type not available for user-space tracing.");
goto error;
if (filter && domain_type == LTTNG_DOMAIN_KERNEL) {
switch (event_rule_type) {
case LTTNG_EVENT_RULE_TYPE_TRACEPOINT:
- case LTTNG_EVENT_RULE_TYPE_SYSCALL:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
break;
default:
ERR("Filter expressions are not supported for %s event rules.",
goto error;
}
- if (validate_exclusion_list(name,
- (const char **) exclude_names.array.buffer
- .data
-
- ) != 0) {
+ if (validate_exclusion_list(name, &exclude_names) != 0) {
/*
* Assume validate_exclusion_list already prints an
* error message.
}
/* Set pattern. */
- event_rule_status = lttng_event_rule_tracepoint_set_pattern(
+ event_rule_status = lttng_event_rule_tracepoint_set_name_pattern(
res.er, name);
if (event_rule_status != LTTNG_EVENT_RULE_STATUS_OK) {
ERR("Failed to set tracepoint event rule's pattern to '%s'.",
n);
event_rule_status =
- lttng_event_rule_tracepoint_add_exclusion(
+ lttng_event_rule_tracepoint_add_name_pattern_exclusion(
res.er,
exclude_name);
if (event_rule_status !=
break;
}
- case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
{
int ret;
enum lttng_event_rule_status event_rule_status;
}
assert(kernel_probe_location);
- res.er = lttng_event_rule_kernel_probe_create(kernel_probe_location);
+ res.er = lttng_event_rule_kernel_kprobe_create(kernel_probe_location);
if (!res.er) {
ERR("Failed to create kprobe event rule.");
goto error;
}
event_rule_status =
- lttng_event_rule_kernel_probe_set_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'.",
break;
}
- case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
{
int ret;
enum lttng_event_rule_status event_rule_status;
goto error;
}
- res.er = lttng_event_rule_userspace_probe_create(userspace_probe_location);
+ res.er = lttng_event_rule_kernel_uprobe_create(userspace_probe_location);
if (!res.er) {
ERR("Failed to create userspace probe event rule.");
goto error;
}
event_rule_status =
- lttng_event_rule_userspace_probe_set_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'.",
break;
}
- case LTTNG_EVENT_RULE_TYPE_SYSCALL:
+ case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
{
enum lttng_event_rule_status event_rule_status;
- enum lttng_event_rule_syscall_emission_site_type emission_site_type;
+ enum lttng_event_rule_kernel_syscall_emission_site emission_site;
if (!parse_syscall_emission_site_from_type(
- event_rule_type_str, &emission_site_type)) {
+ event_rule_type_str, &emission_site)) {
ERR("Failed to parse syscall type '%s'.", event_rule_type_str);
goto error;
}
- res.er = lttng_event_rule_syscall_create(emission_site_type);
+ res.er = lttng_event_rule_kernel_syscall_create(emission_site);
if (!res.er) {
ERR("Failed to create syscall event rule.");
goto error;
}
- event_rule_status = lttng_event_rule_syscall_set_pattern(
+ 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'.",
}
if (filter) {
- event_rule_status = lttng_event_rule_syscall_set_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'.",
static struct lttng_rate_policy *parse_rate_policy(const char *policy_str)
{
- int num_token;
- char **tokens = NULL;
+ int ret;
+ size_t num_token = 0;
+ struct lttng_dynamic_pointer_array tokens;
struct lttng_rate_policy *policy = NULL;
enum lttng_rate_policy_type policy_type;
unsigned long long value;
char *policy_value_str;
assert(policy_str);
+ lttng_dynamic_pointer_array_init(&tokens, NULL);
- /*
- * rate policy fields are separated by ':'.
- */
- tokens = strutils_split(policy_str, ':', 1);
- num_token = strutils_array_of_strings_len(tokens);
+ /* Rate policy fields are separated by ':'. */
+ ret = strutils_split(policy_str, ':', 1, &tokens);
+ if (ret == 0) {
+ num_token = lttng_dynamic_pointer_array_get_count(&tokens);
+ }
/*
* Early sanity check that the number of parameter is exactly 2.
goto end;
}
- policy_type_str = tokens[0];
- policy_value_str = tokens[1];
+ policy_type_str = lttng_dynamic_pointer_array_get_pointer(&tokens, 0);
+ policy_value_str = lttng_dynamic_pointer_array_get_pointer(&tokens, 1);
/* Parse the type. */
if (strcmp(policy_type_str, "once-after") == 0) {
}
end:
- strutils_free_null_terminated_array_of_strings(tokens);
+ lttng_dynamic_pointer_array_reset(&tokens);
return policy;
}
uid = strtol(owner_uid, &end, 10);
if (end == owner_uid || *end != '\0' || errno != 0) {
ERR("Failed to parse `%s` as a user id.", owner_uid);
+ goto error;
}
trigger_status = lttng_trigger_set_owner_uid(trigger, uid);