From 213efb0ce7a2d225778edcce8a55cbe8ef11a572 Mon Sep 17 00:00:00 2001 From: Jonathan Rajotte Date: Tue, 18 May 2021 12:08:15 -0400 Subject: [PATCH] Rename lttng_event_rule_syscall to lttng_event_rule_kernel_syscall MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Allow the usage of "kernel:syscall*" as the `--type` argument for add trigger. A later patch remove the notion of domain. Signed-off-by: Jonathan Rajotte Signed-off-by: Jérémie Galarneau Change-Id: Ib5c87ec937bb0acf9c5133532961dcc31e533884 --- include/Makefile.am | 4 +- include/lttng/event-rule/event-rule.h | 2 +- ...l-internal.h => kernel-syscall-internal.h} | 20 +-- .../{syscall.h => kernel-syscall.h} | 48 +++--- include/lttng/lttng.h | 2 +- src/bin/lttng-sessiond/trace-kernel.c | 20 +-- src/bin/lttng/commands/add_trigger.c | 46 ++++-- src/bin/lttng/commands/list_triggers.c | 20 +-- src/common/Makefile.am | 2 +- src/common/conditions/event-rule-matches.c | 2 +- src/common/event-rule/event-rule.c | 12 +- .../{syscall.c => kernel-syscall.c} | 152 +++++++++--------- .../tools/notification/notification.c | 10 +- .../tools/trigger/test_add_trigger_cli | 20 ++- .../tools/trigger/test_list_triggers_cli | 10 +- tests/unit/test_event_rule.c | 14 +- 16 files changed, 209 insertions(+), 175 deletions(-) rename include/lttng/event-rule/{syscall-internal.h => kernel-syscall-internal.h} (60%) rename include/lttng/event-rule/{syscall.h => kernel-syscall.h} (58%) rename src/common/event-rule/{syscall.c => kernel-syscall.c} (66%) diff --git a/include/Makefile.am b/include/Makefile.am index 53e519067..2f403fe0a 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -153,7 +153,7 @@ lttngtriggerinclude_HEADERS= \ lttngeventruleinclude_HEADERS= \ lttng/event-rule/event-rule.h \ lttng/event-rule/kernel-probe.h \ - lttng/event-rule/syscall.h \ + lttng/event-rule/kernel-syscall.h \ lttng/event-rule/userspace-probe.h \ lttng/event-rule/tracepoint.h @@ -182,7 +182,7 @@ noinst_HEADERS = \ lttng/event-internal.h \ lttng/event-rule/event-rule-internal.h \ lttng/event-rule/kernel-probe-internal.h \ - lttng/event-rule/syscall-internal.h \ + lttng/event-rule/kernel-syscall-internal.h \ lttng/event-rule/tracepoint-internal.h \ lttng/event-rule/userspace-probe-internal.h \ lttng/health-internal.h \ diff --git a/include/lttng/event-rule/event-rule.h b/include/lttng/event-rule/event-rule.h index eec673e00..aac9f5913 100644 --- a/include/lttng/event-rule/event-rule.h +++ b/include/lttng/event-rule/event-rule.h @@ -17,7 +17,7 @@ struct lttng_event_rule; enum lttng_event_rule_type { LTTNG_EVENT_RULE_TYPE_UNKNOWN = -1, LTTNG_EVENT_RULE_TYPE_TRACEPOINT = 0, - LTTNG_EVENT_RULE_TYPE_SYSCALL = 1, + LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL = 1, LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE = 2, LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION = 3, LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE = 4, diff --git a/include/lttng/event-rule/syscall-internal.h b/include/lttng/event-rule/kernel-syscall-internal.h similarity index 60% rename from include/lttng/event-rule/syscall-internal.h rename to include/lttng/event-rule/kernel-syscall-internal.h index 29f9e3316..a5b62743c 100644 --- a/include/lttng/event-rule/syscall-internal.h +++ b/include/lttng/event-rule/kernel-syscall-internal.h @@ -5,17 +5,17 @@ * */ -#ifndef LTTNG_EVENT_RULE_SYSCALL_INTERNAL_H -#define LTTNG_EVENT_RULE_SYSCALL_INTERNAL_H +#ifndef LTTNG_EVENT_RULE_KERNEL_SYSCALL_INTERNAL_H +#define LTTNG_EVENT_RULE_KERNEL_SYSCALL_INTERNAL_H #include #include #include -#include +#include -struct lttng_event_rule_syscall { +struct lttng_event_rule_kernel_syscall { struct lttng_event_rule parent; - enum lttng_event_rule_syscall_emission_site emission_site; + enum lttng_event_rule_kernel_syscall_emission_site emission_site; char *pattern; char *filter_expression; @@ -26,7 +26,7 @@ struct lttng_event_rule_syscall { } internal_filter; }; -struct lttng_event_rule_syscall_comm { +struct lttng_event_rule_kernel_syscall_comm { uint32_t emission_site; /* Includes terminator `\0`. */ uint32_t pattern_len; @@ -41,11 +41,11 @@ struct lttng_event_rule_syscall_comm { } LTTNG_PACKED; LTTNG_HIDDEN -ssize_t lttng_event_rule_syscall_create_from_payload( +ssize_t lttng_event_rule_kernel_syscall_create_from_payload( struct lttng_payload_view *view, struct lttng_event_rule **rule); LTTNG_HIDDEN -const char *lttng_event_rule_syscall_emission_site_str( - enum lttng_event_rule_syscall_emission_site emission_site); -#endif /* LTTNG_EVENT_RULE_SYSCALL_INTERNAL_H */ +const char *lttng_event_rule_kernel_syscall_emission_site_str( + enum lttng_event_rule_kernel_syscall_emission_site emission_site); +#endif /* LTTNG_EVENT_RULE_KERNEL_SYSCALL_INTERNAL_H */ diff --git a/include/lttng/event-rule/syscall.h b/include/lttng/event-rule/kernel-syscall.h similarity index 58% rename from include/lttng/event-rule/syscall.h rename to include/lttng/event-rule/kernel-syscall.h index f9fd2aba3..1db691587 100644 --- a/include/lttng/event-rule/syscall.h +++ b/include/lttng/event-rule/kernel-syscall.h @@ -5,8 +5,8 @@ * */ -#ifndef LTTNG_EVENT_RULE_SYSCALL_H -#define LTTNG_EVENT_RULE_SYSCALL_H +#ifndef LTTNG_EVENT_RULE_KERNEL_SYSCALL_H +#define LTTNG_EVENT_RULE_KERNEL_SYSCALL_H #include @@ -14,27 +14,27 @@ extern "C" { #endif -enum lttng_event_rule_syscall_emission_site { - LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT = 0, - LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY = 1, - LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT = 2, - LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_UNKNOWN = -1, +enum lttng_event_rule_kernel_syscall_emission_site { + LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT = 0, + LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY = 1, + LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT = 2, + LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN = -1, }; /* - * Create a newly allocated syscall event rule. + * Create a newly allocated kernel syscall event rule. * * The default pattern is '*'. - * The default emission site is LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT. + * The default emission site is LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT. * * Returns a new event rule on success, NULL on failure. This event rule must be * destroyed using lttng_event_rule_destroy(). */ -extern struct lttng_event_rule *lttng_event_rule_syscall_create(enum - lttng_event_rule_syscall_emission_site emission_site); +extern struct lttng_event_rule *lttng_event_rule_kernel_syscall_create(enum + lttng_event_rule_kernel_syscall_emission_site emission_site); /* - * Set the name pattern of a syscall event rule. + * Set the name pattern of a kernel syscall event rule. * * Pattern can contain wildcard '*'. See man lttng-enable-event. * @@ -43,11 +43,11 @@ extern struct lttng_event_rule *lttng_event_rule_syscall_create(enum * Returns LTTNG_EVENT_RULE_STATUS_OK on success, LTTNG_EVENT_RULE_STATUS_INVALID * if invalid parameters are passed. */ -extern enum lttng_event_rule_status lttng_event_rule_syscall_set_name_pattern( +extern enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_name_pattern( struct lttng_event_rule *rule, const char *pattern); /* - * Get the name pattern of a syscall event rule. + * Get the name pattern of a kernel syscall event rule. * * The caller does not assume the ownership of the returned pattern. The * pattern shall only only be used for the duration of the event rule's @@ -58,22 +58,22 @@ extern enum lttng_event_rule_status lttng_event_rule_syscall_set_name_pattern( * parameter is passed, or LTTNG_EVENT_RULE_STATUS_UNSET if a pattern * was not set prior to this call. */ -extern enum lttng_event_rule_status lttng_event_rule_syscall_get_name_pattern( +extern enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_name_pattern( const struct lttng_event_rule *rule, const char **pattern); /* - * Set the filter expression of a syscall event rule. + * Set the filter expression of a kernel syscall event rule. * * The expression is copied internally. * * Returns LTTNG_EVENT_RULE_STATUS_OK on success, LTTNG_EVENT_RULE_STATUS_INVALID * if invalid parameters are passed. */ -extern enum lttng_event_rule_status lttng_event_rule_syscall_set_filter( +extern enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_filter( struct lttng_event_rule *rule, const char *expression); /* - * Get the filter expression of a syscall event rule. + * Get the filter expression of a kernel syscall event rule. * * The caller does not assume the ownership of the returned filter expression. * The filter expression shall only only be used for the duration of the event @@ -84,20 +84,20 @@ extern enum lttng_event_rule_status lttng_event_rule_syscall_set_filter( * parameter is passed, or LTTNG_EVENT_RULE_STATUS_UNSET if a filter expression * was not set prior to this call. */ -extern enum lttng_event_rule_status lttng_event_rule_syscall_get_filter( +extern enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_filter( const struct lttng_event_rule *rule, const char **expression); /* - * Get the emission site of a syscall event rule. + * Get the emission site of a kernel syscall event rule. * - * Returns a enum lttng_event_rule_syscall_emission_site. + * Returns a enum lttng_event_rule_kernel_syscall_emission_site. */ -extern enum lttng_event_rule_syscall_emission_site -lttng_event_rule_syscall_get_emission_site( +extern enum lttng_event_rule_kernel_syscall_emission_site +lttng_event_rule_kernel_syscall_get_emission_site( const struct lttng_event_rule *rule); #ifdef __cplusplus } #endif -#endif /* LTTNG_EVENT_RULE_SYSCALL_H */ +#endif /* LTTNG_EVENT_RULE_KERNEL_SYSCALL_H */ diff --git a/include/lttng/lttng.h b/include/lttng/lttng.h index 4736e8b34..fc242c511 100644 --- a/include/lttng/lttng.h +++ b/include/lttng/lttng.h @@ -43,7 +43,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/src/bin/lttng-sessiond/trace-kernel.c b/src/bin/lttng-sessiond/trace-kernel.c index 7ba6a4cd9..423bb0730 100644 --- a/src/bin/lttng-sessiond/trace-kernel.c +++ b/src/bin/lttng-sessiond/trace-kernel.c @@ -20,8 +20,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -671,27 +671,27 @@ enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule( ret_code = LTTNG_OK; break; } - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: { const enum lttng_event_rule_status status = - lttng_event_rule_syscall_get_name_pattern( + lttng_event_rule_kernel_syscall_get_name_pattern( rule, &name); - const enum lttng_event_rule_syscall_emission_site + const enum lttng_event_rule_kernel_syscall_emission_site emission_site = - lttng_event_rule_syscall_get_emission_site(rule); + lttng_event_rule_kernel_syscall_get_emission_site(rule); enum lttng_kernel_abi_syscall_entryexit entryexit; assert(status == LTTNG_EVENT_RULE_STATUS_OK); - assert(emission_site != LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_UNKNOWN); + assert(emission_site != LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN); switch(emission_site) { - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY: entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRY; break; - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT: entryexit = LTTNG_KERNEL_ABI_SYSCALL_EXIT; break; - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT: entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT; break; default: diff --git a/src/bin/lttng/commands/add_trigger.c b/src/bin/lttng/commands/add_trigger.c index 1cb35adc7..a1bfe240e 100644 --- a/src/bin/lttng/commands/add_trigger.c +++ b/src/bin/lttng/commands/add_trigger.c @@ -135,7 +135,9 @@ bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) *dest = LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE; } 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 @@ -143,10 +145,15 @@ bool assign_event_rule_type(enum lttng_event_rule_type *dest, const char *arg) * - 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; @@ -189,16 +196,27 @@ end: } static bool parse_syscall_emission_site_from_type(const char *str, - enum lttng_event_rule_syscall_emission_site *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; } @@ -838,7 +856,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) */ 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("*"); } @@ -917,7 +935,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: 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_SYSCALL: if (domain_type != LTTNG_DOMAIN_KERNEL) { ERR("Event type not available for user-space tracing."); goto error; @@ -939,7 +957,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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.", @@ -1131,10 +1149,10 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) 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 emission_site; + enum lttng_event_rule_kernel_syscall_emission_site emission_site; if (!parse_syscall_emission_site_from_type( event_rule_type_str, &emission_site)) { @@ -1142,13 +1160,13 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) goto error; } - res.er = lttng_event_rule_syscall_create(emission_site); + 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_name_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'.", @@ -1157,7 +1175,7 @@ struct parse_event_rule_res parse_event_rule(int *argc, const char ***argv) } 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'.", diff --git a/src/bin/lttng/commands/list_triggers.c b/src/bin/lttng/commands/list_triggers.c index 26dc201ec..10f76e843 100644 --- a/src/bin/lttng/commands/list_triggers.c +++ b/src/bin/lttng/commands/list_triggers.c @@ -18,8 +18,8 @@ #include "lttng/condition/event-rule-matches-internal.h" /* For lttng_domain_type_str(). */ #include "lttng/domain-internal.h" -/* For lttng_event_rule_syscall_emission_site_str() */ -#include "lttng/event-rule/syscall-internal.h" +/* For lttng_event_rule_kernel_syscall_emission_site_str() */ +#include "lttng/event-rule/kernel-syscall-internal.h" #include "../loglevel.h" #include @@ -389,22 +389,22 @@ void print_event_rule_syscall(const struct lttng_event_rule *event_rule) { const char *pattern, *filter; enum lttng_event_rule_status event_rule_status; - enum lttng_event_rule_syscall_emission_site emission_site; + enum lttng_event_rule_kernel_syscall_emission_site emission_site; - assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_SYSCALL); + assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL); emission_site = - lttng_event_rule_syscall_get_emission_site(event_rule); + lttng_event_rule_kernel_syscall_get_emission_site(event_rule); - event_rule_status = lttng_event_rule_syscall_get_name_pattern( + event_rule_status = lttng_event_rule_kernel_syscall_get_name_pattern( event_rule, &pattern); assert(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK); - _MSG(" rule: %s (type: syscall:%s", pattern, - lttng_event_rule_syscall_emission_site_str( + _MSG(" rule: %s (type: kernel:syscall:%s", pattern, + lttng_event_rule_kernel_syscall_emission_site_str( emission_site)); - event_rule_status = lttng_event_rule_syscall_get_filter( + event_rule_status = lttng_event_rule_kernel_syscall_get_filter( event_rule, &filter); if (event_rule_status == LTTNG_EVENT_RULE_STATUS_OK) { _MSG(", filter: %s", filter); @@ -431,7 +431,7 @@ void print_event_rule(const struct lttng_event_rule *event_rule) case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: print_event_rule_userspace_probe(event_rule); break; - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: print_event_rule_syscall(event_rule); break; default: diff --git a/src/common/Makefile.am b/src/common/Makefile.am index a38325d5a..32e9c02ab 100644 --- a/src/common/Makefile.am +++ b/src/common/Makefile.am @@ -66,7 +66,7 @@ libcommon_la_SOURCES = \ event-field-value.c \ event-rule/event-rule.c \ event-rule/kernel-probe.c \ - event-rule/syscall.c \ + event-rule/kernel-syscall.c \ event-rule/userspace-probe.c \ event-rule/tracepoint.c \ filter.c filter.h \ diff --git a/src/common/conditions/event-rule-matches.c b/src/common/conditions/event-rule-matches.c index bbde91aeb..b2abcc764 100644 --- a/src/common/conditions/event-rule-matches.c +++ b/src/common/conditions/event-rule-matches.c @@ -798,7 +798,7 @@ lttng_condition_event_rule_matches_append_capture_descriptor( switch(lttng_event_rule_get_type(rule)) { case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: /* Supported. */ status = LTTNG_CONDITION_STATUS_OK; break; diff --git a/src/common/event-rule/event-rule.c b/src/common/event-rule/event-rule.c index 841e182b3..0443c75e9 100644 --- a/src/common/event-rule/event-rule.c +++ b/src/common/event-rule/event-rule.c @@ -15,7 +15,7 @@ #include #include #include -#include +#include #include #include #include @@ -40,7 +40,7 @@ enum lttng_domain_type lttng_event_rule_get_domain_type( assert(status == LTTNG_EVENT_RULE_STATUS_OK); break; } - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION: case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: @@ -181,9 +181,9 @@ ssize_t lttng_event_rule_create_from_payload( case LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE: create_from_payload = lttng_event_rule_userspace_probe_create_from_payload; break; - case LTTNG_EVENT_RULE_TYPE_SYSCALL: + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: create_from_payload = - lttng_event_rule_syscall_create_from_payload; + lttng_event_rule_kernel_syscall_create_from_payload; break; default: ERR("Attempted to create event rule of unknown type (%i)", @@ -313,8 +313,8 @@ const char *lttng_event_rule_type_str(enum lttng_event_rule_type type) return "unknown"; case LTTNG_EVENT_RULE_TYPE_TRACEPOINT: return "tracepoint"; - case LTTNG_EVENT_RULE_TYPE_SYSCALL: - return "syscall"; + case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL: + return "kernel syscall"; case LTTNG_EVENT_RULE_TYPE_KERNEL_PROBE: return "probe"; case LTTNG_EVENT_RULE_TYPE_KERNEL_FUNCTION: diff --git a/src/common/event-rule/syscall.c b/src/common/event-rule/kernel-syscall.c similarity index 66% rename from src/common/event-rule/syscall.c rename to src/common/event-rule/kernel-syscall.c index 4ac6a11af..a2a77a3c4 100644 --- a/src/common/event-rule/syscall.c +++ b/src/common/event-rule/kernel-syscall.c @@ -16,20 +16,20 @@ #include #include #include -#include +#include #define IS_SYSCALL_EVENT_RULE(rule) \ - (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_SYSCALL) + (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL) -static void lttng_event_rule_syscall_destroy(struct lttng_event_rule *rule) +static void lttng_event_rule_kernel_syscall_destroy(struct lttng_event_rule *rule) { - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; if (rule == NULL) { return; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); free(syscall->pattern); free(syscall->filter_expression); @@ -38,17 +38,17 @@ static void lttng_event_rule_syscall_destroy(struct lttng_event_rule *rule) free(syscall); } -static bool lttng_event_rule_syscall_validate( +static bool lttng_event_rule_kernel_syscall_validate( const struct lttng_event_rule *rule) { bool valid = false; - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; if (!rule) { goto end; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); /* Required field. */ if (!syscall->pattern) { @@ -61,14 +61,14 @@ end: return valid; } -static int lttng_event_rule_syscall_serialize( +static int lttng_event_rule_kernel_syscall_serialize( const struct lttng_event_rule *rule, struct lttng_payload *payload) { int ret; size_t pattern_len, filter_expression_len; - struct lttng_event_rule_syscall *syscall; - struct lttng_event_rule_syscall_comm syscall_comm; + struct lttng_event_rule_kernel_syscall *syscall; + struct lttng_event_rule_kernel_syscall_comm syscall_comm; if (!rule || !IS_SYSCALL_EVENT_RULE(rule)) { ret = -1; @@ -76,7 +76,7 @@ static int lttng_event_rule_syscall_serialize( } DBG("Serializing syscall event rule"); - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); pattern_len = strlen(syscall->pattern) + 1; @@ -108,14 +108,14 @@ end: return ret; } -static bool lttng_event_rule_syscall_is_equal(const struct lttng_event_rule *_a, +static bool lttng_event_rule_kernel_syscall_is_equal(const struct lttng_event_rule *_a, const struct lttng_event_rule *_b) { bool is_equal = false; - struct lttng_event_rule_syscall *a, *b; + struct lttng_event_rule_kernel_syscall *a, *b; - a = container_of(_a, struct lttng_event_rule_syscall, parent); - b = container_of(_b, struct lttng_event_rule_syscall, parent); + a = container_of(_a, struct lttng_event_rule_kernel_syscall, parent); + b = container_of(_b, struct lttng_event_rule_kernel_syscall, parent); if (!!a->filter_expression != !!b->filter_expression) { goto end; @@ -141,23 +141,23 @@ end: return is_equal; } -static enum lttng_error_code lttng_event_rule_syscall_generate_filter_bytecode( +static enum lttng_error_code lttng_event_rule_kernel_syscall_generate_filter_bytecode( struct lttng_event_rule *rule, const struct lttng_credentials *creds) { int ret; enum lttng_error_code ret_code = LTTNG_OK; - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status; const char *filter; struct lttng_bytecode *bytecode = NULL; assert(rule); - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); /* Generate the filter bytecode. */ - status = lttng_event_rule_syscall_get_filter(rule, &filter); + status = lttng_event_rule_kernel_syscall_get_filter(rule, &filter); if (status == LTTNG_EVENT_RULE_STATUS_UNSET) { filter = NULL; } else if (status != LTTNG_EVENT_RULE_STATUS_OK) { @@ -196,31 +196,31 @@ end: return ret_code; } -static const char *lttng_event_rule_syscall_get_internal_filter( +static const char *lttng_event_rule_kernel_syscall_get_internal_filter( const struct lttng_event_rule *rule) { - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; assert(rule); - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); return syscall->internal_filter.filter; } static const struct lttng_bytecode * -lttng_event_rule_syscall_get_internal_filter_bytecode( +lttng_event_rule_kernel_syscall_get_internal_filter_bytecode( const struct lttng_event_rule *rule) { - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; assert(rule); - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); return syscall->internal_filter.bytecode; } static enum lttng_event_rule_generate_exclusions_status -lttng_event_rule_syscall_generate_exclusions(const struct lttng_event_rule *rule, +lttng_event_rule_kernel_syscall_generate_exclusions(const struct lttng_event_rule *rule, struct lttng_event_exclusion **exclusions) { /* Unsupported. */ @@ -229,14 +229,14 @@ lttng_event_rule_syscall_generate_exclusions(const struct lttng_event_rule *rule } static unsigned long -lttng_event_rule_syscall_hash( +lttng_event_rule_kernel_syscall_hash( const struct lttng_event_rule *rule) { unsigned long hash; - struct lttng_event_rule_syscall *syscall_rule = + struct lttng_event_rule_kernel_syscall *syscall_rule = container_of(rule, typeof(*syscall_rule), parent); - hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_SYSCALL, + hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL, lttng_ht_seed); hash ^= hash_key_str(syscall_rule->pattern, lttng_ht_seed); if (syscall_rule->filter_expression) { @@ -247,49 +247,49 @@ lttng_event_rule_syscall_hash( return hash; } -struct lttng_event_rule *lttng_event_rule_syscall_create( - enum lttng_event_rule_syscall_emission_site +struct lttng_event_rule *lttng_event_rule_kernel_syscall_create( + enum lttng_event_rule_kernel_syscall_emission_site emission_site) { struct lttng_event_rule *rule = NULL; - struct lttng_event_rule_syscall *syscall_rule; + struct lttng_event_rule_kernel_syscall *syscall_rule; enum lttng_event_rule_status status; /* Validate the emission site type */ switch (emission_site) { - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT: - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY: - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT: break; default: /* Invalid emission type */ goto end; } - syscall_rule = zmalloc(sizeof(struct lttng_event_rule_syscall)); + syscall_rule = zmalloc(sizeof(struct lttng_event_rule_kernel_syscall)); if (!syscall_rule) { goto end; } rule = &syscall_rule->parent; lttng_event_rule_init( - &syscall_rule->parent, LTTNG_EVENT_RULE_TYPE_SYSCALL); - syscall_rule->parent.validate = lttng_event_rule_syscall_validate; - syscall_rule->parent.serialize = lttng_event_rule_syscall_serialize; - syscall_rule->parent.equal = lttng_event_rule_syscall_is_equal; - syscall_rule->parent.destroy = lttng_event_rule_syscall_destroy; + &syscall_rule->parent, LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL); + syscall_rule->parent.validate = lttng_event_rule_kernel_syscall_validate; + syscall_rule->parent.serialize = lttng_event_rule_kernel_syscall_serialize; + syscall_rule->parent.equal = lttng_event_rule_kernel_syscall_is_equal; + syscall_rule->parent.destroy = lttng_event_rule_kernel_syscall_destroy; syscall_rule->parent.generate_filter_bytecode = - lttng_event_rule_syscall_generate_filter_bytecode; + lttng_event_rule_kernel_syscall_generate_filter_bytecode; syscall_rule->parent.get_filter = - lttng_event_rule_syscall_get_internal_filter; + lttng_event_rule_kernel_syscall_get_internal_filter; syscall_rule->parent.get_filter_bytecode = - lttng_event_rule_syscall_get_internal_filter_bytecode; + lttng_event_rule_kernel_syscall_get_internal_filter_bytecode; syscall_rule->parent.generate_exclusions = - lttng_event_rule_syscall_generate_exclusions; - syscall_rule->parent.hash = lttng_event_rule_syscall_hash; + lttng_event_rule_kernel_syscall_generate_exclusions; + syscall_rule->parent.hash = lttng_event_rule_kernel_syscall_hash; /* Default pattern is '*'. */ - status = lttng_event_rule_syscall_set_name_pattern(rule, "*"); + status = lttng_event_rule_kernel_syscall_set_name_pattern(rule, "*"); if (status != LTTNG_EVENT_RULE_STATUS_OK) { lttng_event_rule_destroy(rule); rule = NULL; @@ -303,13 +303,13 @@ end: } LTTNG_HIDDEN -ssize_t lttng_event_rule_syscall_create_from_payload( +ssize_t lttng_event_rule_kernel_syscall_create_from_payload( struct lttng_payload_view *view, struct lttng_event_rule **_event_rule) { ssize_t ret, offset = 0; enum lttng_event_rule_status status; - const struct lttng_event_rule_syscall_comm *syscall_comm; + const struct lttng_event_rule_kernel_syscall_comm *syscall_comm; const char *pattern; const char *filter_expression = NULL; struct lttng_buffer_view current_buffer_view; @@ -334,7 +334,7 @@ ssize_t lttng_event_rule_syscall_create_from_payload( } syscall_comm = (typeof(syscall_comm)) current_buffer_view.data; - rule = lttng_event_rule_syscall_create(syscall_comm->emission_site); + rule = lttng_event_rule_kernel_syscall_create(syscall_comm->emission_site); if (!rule) { ERR("Failed to create event rule syscall"); ret = -1; @@ -387,7 +387,7 @@ ssize_t lttng_event_rule_syscall_create_from_payload( skip_filter_expression: - status = lttng_event_rule_syscall_set_name_pattern(rule, pattern); + status = lttng_event_rule_kernel_syscall_set_name_pattern(rule, pattern); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set event rule syscall pattern"); ret = -1; @@ -395,7 +395,7 @@ skip_filter_expression: } if (filter_expression) { - status = lttng_event_rule_syscall_set_filter( + status = lttng_event_rule_kernel_syscall_set_filter( rule, filter_expression); if (status != LTTNG_EVENT_RULE_STATUS_OK) { ERR("Failed to set event rule syscall pattern"); @@ -412,11 +412,11 @@ end: return ret; } -enum lttng_event_rule_status lttng_event_rule_syscall_set_name_pattern( +enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_name_pattern( struct lttng_event_rule *rule, const char *pattern) { char *pattern_copy = NULL; - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !pattern || @@ -425,7 +425,7 @@ enum lttng_event_rule_status lttng_event_rule_syscall_set_name_pattern( goto end; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); pattern_copy = strdup(pattern); if (!pattern_copy) { status = LTTNG_EVENT_RULE_STATUS_ERROR; @@ -442,10 +442,10 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_syscall_get_name_pattern( +enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_name_pattern( const struct lttng_event_rule *rule, const char **pattern) { - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !pattern) { @@ -453,7 +453,7 @@ enum lttng_event_rule_status lttng_event_rule_syscall_get_name_pattern( goto end; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); if (!syscall->pattern) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; @@ -464,11 +464,11 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_syscall_set_filter( +enum lttng_event_rule_status lttng_event_rule_kernel_syscall_set_filter( struct lttng_event_rule *rule, const char *expression) { char *expression_copy = NULL; - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; /* TODO: validate that the passed expression is valid. */ @@ -479,7 +479,7 @@ enum lttng_event_rule_status lttng_event_rule_syscall_set_filter( goto end; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); expression_copy = strdup(expression); if (!expression_copy) { status = LTTNG_EVENT_RULE_STATUS_ERROR; @@ -496,10 +496,10 @@ end: return status; } -enum lttng_event_rule_status lttng_event_rule_syscall_get_filter( +enum lttng_event_rule_status lttng_event_rule_kernel_syscall_get_filter( const struct lttng_event_rule *rule, const char **expression) { - struct lttng_event_rule_syscall *syscall; + struct lttng_event_rule_kernel_syscall *syscall; enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK; if (!rule || !IS_SYSCALL_EVENT_RULE(rule) || !expression) { @@ -507,7 +507,7 @@ enum lttng_event_rule_status lttng_event_rule_syscall_get_filter( goto end; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); if (!syscall->filter_expression) { status = LTTNG_EVENT_RULE_STATUS_UNSET; goto end; @@ -517,19 +517,19 @@ enum lttng_event_rule_status lttng_event_rule_syscall_get_filter( end: return status; } -extern enum lttng_event_rule_syscall_emission_site -lttng_event_rule_syscall_get_emission_site( +extern enum lttng_event_rule_kernel_syscall_emission_site +lttng_event_rule_kernel_syscall_get_emission_site( const struct lttng_event_rule *rule) { - enum lttng_event_rule_syscall_emission_site emission_site = - LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_UNKNOWN; - struct lttng_event_rule_syscall *syscall; + enum lttng_event_rule_kernel_syscall_emission_site emission_site = + LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN; + struct lttng_event_rule_kernel_syscall *syscall; if (!rule || !IS_SYSCALL_EVENT_RULE(rule)) { goto end; } - syscall = container_of(rule, struct lttng_event_rule_syscall, parent); + syscall = container_of(rule, struct lttng_event_rule_kernel_syscall, parent); emission_site = syscall->emission_site; end: @@ -537,15 +537,15 @@ end: } LTTNG_HIDDEN -const char *lttng_event_rule_syscall_emission_site_str( - enum lttng_event_rule_syscall_emission_site emission_site) +const char *lttng_event_rule_kernel_syscall_emission_site_str( + enum lttng_event_rule_kernel_syscall_emission_site emission_site) { switch (emission_site) { - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY: return "entry"; - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY_EXIT: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT: return "entry+exit"; - case LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_EXIT: + case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT: return "exit"; default: return "???"; diff --git a/tests/regression/tools/notification/notification.c b/tests/regression/tools/notification/notification.c index 9638bb452..e089d47c0 100644 --- a/tests/regression/tools/notification/notification.c +++ b/tests/regression/tools/notification/notification.c @@ -2054,10 +2054,10 @@ static void test_syscall_event_rule_notification( lttng_session_daemon_notification_endpoint); ok(notification_channel, "Notification channel object creation"); - event_rule = lttng_event_rule_syscall_create(LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY); + event_rule = lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY); ok(event_rule, "syscall event rule object creation"); - event_rule_status = lttng_event_rule_syscall_set_name_pattern( + event_rule_status = lttng_event_rule_kernel_syscall_set_name_pattern( event_rule, syscall_name); ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK, "Setting syscall event rule pattern: '%s'", syscall_name); @@ -2140,15 +2140,15 @@ static void test_syscall_event_rule_notification_filter( lttng_session_daemon_notification_endpoint); ok(notification_channel, "Notification channel object creation"); - event_rule = lttng_event_rule_syscall_create(LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY); + event_rule = lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY); ok(event_rule, "syscall event rule object creation"); - event_rule_status = lttng_event_rule_syscall_set_name_pattern( + event_rule_status = lttng_event_rule_kernel_syscall_set_name_pattern( event_rule, syscall_name); ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK, "Setting syscall event rule pattern: '%s'", syscall_name); - event_rule_status = lttng_event_rule_syscall_set_filter( + event_rule_status = lttng_event_rule_kernel_syscall_set_filter( event_rule, filter_pattern); ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK, "Setting filter: '%s'", filter_pattern); diff --git a/tests/regression/tools/trigger/test_add_trigger_cli b/tests/regression/tools/trigger/test_add_trigger_cli index 0b551d4d1..029f17cef 100755 --- a/tests/regression/tools/trigger/test_add_trigger_cli +++ b/tests/regression/tools/trigger/test_add_trigger_cli @@ -23,7 +23,7 @@ TESTDIR="$CURDIR/../../.." # shellcheck source=../../../utils/utils.sh source "$TESTDIR/utils/utils.sh" -plan_tests 285 +plan_tests 297 FULL_LTTNG_BIN="${TESTDIR}/../src/bin/lttng/${LTTNG_BIN}" @@ -190,7 +190,7 @@ skip $ist_root "non-root user: skipping uprobe tests" 12 || { done } -skip $ist_root "non-root user: skipping syscall tests" 18 || { +skip $ist_root "non-root user: skipping syscall tests" 30 || { test_success "--condition event-rule-matches one syscall" \ --condition event-rule-matches --domain=kernel --type=syscall --name=open \ --action notify @@ -211,6 +211,22 @@ skip $ist_root "non-root user: skipping syscall tests" 18 || { test_success "--condition event-rule-matches one syscall:entry-exit" \ --condition event-rule-matches --domain=kernel --type=syscall:entry+exit --name=open \ --action notify + + # Same thing but with "kernel:syscall" type instead: + test_success "--condition event-rule-matches one syscall" \ + --condition event-rule-matches --domain=kernel --type=kernel:syscall --name=open \ + --action notify + + test_success "--condition event-rule-matches one kernel:syscall:entry" \ + --condition event-rule-matches --domain=kernel --type=kernel:syscall:entry --name=open \ + --action notify + test_success "--condition event-rule-matches one kernel:syscall:exit" \ + --condition event-rule-matches --domain=kernel --type=kernel:syscall:exit --name=open \ + --action notify + test_success "--condition event-rule-matches one kernel:syscall:entry-exit" \ + --condition event-rule-matches --domain=kernel --type=kernel:syscall:entry+exit --name=open \ + --action notify + } # `--action notify` successes diff --git a/tests/regression/tools/trigger/test_list_triggers_cli b/tests/regression/tools/trigger/test_list_triggers_cli index 26f2f9f46..cfeab29b7 100755 --- a/tests/regression/tools/trigger/test_list_triggers_cli +++ b/tests/regression/tools/trigger/test_list_triggers_cli @@ -318,7 +318,7 @@ test_event_rule_matches_syscall () - name: T0 owner uid: ${uid} condition: event rule matches - rule: open (type: syscall:entry+exit) + rule: open (type: kernel:syscall:entry+exit) actions: notify errors: none @@ -326,7 +326,7 @@ test_event_rule_matches_syscall () - name: T1 owner uid: ${uid} condition: event rule matches - rule: open (type: syscall:entry) + rule: open (type: kernel:syscall:entry) actions: notify errors: none @@ -334,7 +334,7 @@ test_event_rule_matches_syscall () - name: T2 owner uid: ${uid} condition: event rule matches - rule: open (type: syscall:exit) + rule: open (type: kernel:syscall:exit) actions: notify errors: none @@ -342,7 +342,7 @@ test_event_rule_matches_syscall () - name: T3 owner uid: ${uid} condition: event rule matches - rule: open (type: syscall:entry+exit) + rule: open (type: kernel:syscall:entry+exit) actions: notify errors: none @@ -350,7 +350,7 @@ test_event_rule_matches_syscall () - name: T4 owner uid: ${uid} condition: event rule matches - rule: ptrace (type: syscall:entry+exit, filter: a > 2) + rule: ptrace (type: kernel:syscall:entry+exit, filter: a > 2) actions: notify errors: none diff --git a/tests/unit/test_event_rule.c b/tests/unit/test_event_rule.c index f30343b30..6ec49fe66 100644 --- a/tests/unit/test_event_rule.c +++ b/tests/unit/test_event_rule.c @@ -20,8 +20,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -184,18 +184,18 @@ static void test_event_rule_syscall(void) lttng_payload_init(&payload); - syscall = lttng_event_rule_syscall_create(LTTNG_EVENT_RULE_SYSCALL_EMISSION_SITE_ENTRY); + syscall = lttng_event_rule_kernel_syscall_create(LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY); ok(syscall, "syscall object."); - status = lttng_event_rule_syscall_set_name_pattern(syscall, pattern); + status = lttng_event_rule_kernel_syscall_set_name_pattern(syscall, pattern); ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting pattern."); - status = lttng_event_rule_syscall_get_name_pattern(syscall, &tmp); + status = lttng_event_rule_kernel_syscall_get_name_pattern(syscall, &tmp); ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting pattern."); ok(!strncmp(pattern, tmp, strlen(pattern)), "pattern is equal."); - status = lttng_event_rule_syscall_set_filter(syscall, filter); + status = lttng_event_rule_kernel_syscall_set_filter(syscall, filter); ok(status == LTTNG_EVENT_RULE_STATUS_OK, "setting filter."); - status = lttng_event_rule_syscall_get_filter(syscall, &tmp); + status = lttng_event_rule_kernel_syscall_get_filter(syscall, &tmp); ok(status == LTTNG_EVENT_RULE_STATUS_OK, "getting filter."); ok(!strncmp(filter, tmp, strlen(filter)), "filter is equal."); -- 2.34.1