X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=tests%2Fregression%2Ftools%2Fnotification%2Fnotification.c;h=73415c51ecc51d3fc58675fd1fd2d764f96d5998;hp=8fa0d3d37f17fb41b5dd47e66ebea7e2dfd50ef3;hb=a877d1b540f7a093be85c9866575b1e44bfd7cb8;hpb=45294d8ae0bc7258ac612bd8b4fba18bd7c4bf55 diff --git a/tests/regression/tools/notification/notification.c b/tests/regression/tools/notification/notification.c index 8fa0d3d37..73415c51e 100644 --- a/tests/regression/tools/notification/notification.c +++ b/tests/regression/tools/notification/notification.c @@ -24,25 +24,7 @@ #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include #include -#include -#include -#include -#include #include @@ -51,6 +33,65 @@ int named_pipe_args_start = 0; pid_t app_pid = 0; const char *app_state_file = NULL; +static const char *get_notification_trigger_name( + struct lttng_notification *notification) +{ + const char *name = NULL; + enum lttng_evaluation_status status; + const struct lttng_evaluation *evaluation; + evaluation = lttng_notification_get_evaluation(notification); + if (evaluation == NULL) { + fail("lttng_notification_get_evaluation"); + goto end; + } + + switch (lttng_evaluation_get_type(evaluation)) { + case LTTNG_CONDITION_TYPE_EVENT_RULE_HIT: + { + status = lttng_evaluation_event_rule_get_trigger_name( + evaluation, &name); + if (status != LTTNG_EVALUATION_STATUS_OK) { + fail("lttng_evaluation_event_rule_get_trigger_name"); + name = NULL; + goto end; + } + break; + } + default: + fail("Wrong notification evaluation type \n"); + goto end; + } +end: + return name; +} + +static int validator_notification_trigger_name( + struct lttng_notification *notification, + const char *trigger_name) +{ + int ret; + bool name_is_equal; + const char *name; + + assert(notification); + assert(trigger_name); + + name = get_notification_trigger_name(notification); + if (name == NULL) { + ret = 1; + goto end; + } + + name_is_equal = (strcmp(trigger_name, name) == 0); + ok(name_is_equal, "Expected trigger name: %s got %s", trigger_name, + name); + + ret = !name_is_equal; + +end: + return ret; +} + static void wait_on_file(const char *path, bool file_exist) { @@ -943,58 +984,39 @@ static void create_tracepoint_event_rule_trigger(const char *event_pattern, return; } -static char *get_next_notification_trigger_name( +static struct lttng_notification *get_next_notification( struct lttng_notification_channel *notification_channel) { - struct lttng_notification *notification; + struct lttng_notification *local_notification = NULL; enum lttng_notification_channel_status status; - const struct lttng_evaluation *notification_evaluation; - char *trigger_name = NULL; - const char *name; - enum lttng_condition_type notification_evaluation_type; /* Receive the next notification. */ status = lttng_notification_channel_get_next_notification( - notification_channel, ¬ification); + notification_channel, &local_notification); switch (status) { case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK: break; - default: - /* Unhandled conditions / errors. */ - fail("Failed to get next notification channel notification: status = %d", - status); - goto end; - } - - notification_evaluation = - lttng_notification_get_evaluation(notification); - - notification_evaluation_type = - lttng_evaluation_get_type(notification_evaluation); - switch (notification_evaluation_type) { - case LTTNG_CONDITION_TYPE_EVENT_RULE_HIT: - lttng_evaluation_event_rule_get_trigger_name( - notification_evaluation, &name); - - trigger_name = strdup(name); + case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED: + fail("Notifications have been dropped"); + local_notification = NULL; break; default: - fail("Unexpected notification evaluation type: notification type = %d", - notification_evaluation_type); + /* Unhandled conditions / errors. */ + fail("Failed to get next notification (unknown notification channel status): status = %d", + (int) status); + local_notification = NULL; break; } - lttng_notification_destroy(notification); - -end: - return trigger_name; + return local_notification; } static void test_tracepoint_event_rule_notification( enum lttng_domain_type domain_type) { int i; + int ret; const int notification_count = 3; enum lttng_notification_channel_status nc_status; struct lttng_action *action = NULL; @@ -1024,17 +1046,27 @@ static void test_tracepoint_event_rule_notification( resume_application(); - /* Get 3 notifications. */ + /* Get notifications. */ for (i = 0; i < notification_count; i++) { - char *name = get_next_notification_trigger_name( + struct lttng_notification *notification = get_next_notification( notification_channel); - ok(strcmp(trigger_name, name) == 0, - "Received notification for the expected trigger name: '%s' (%d/%d)", - trigger_name, i + 1, notification_count); - free(name); + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + ret = validator_notification_trigger_name(notification, trigger_name); + lttng_notification_destroy(notification); + if (ret) { + goto end; + } } +end: suspend_application(); lttng_notification_channel_destroy(notification_channel); lttng_unregister_trigger(trigger); @@ -1048,8 +1080,8 @@ static void test_tracepoint_event_rule_notification_filter( enum lttng_domain_type domain_type) { int i; + const int notification_count = 3; enum lttng_notification_channel_status nc_status; - struct lttng_condition *ctrl_condition = NULL, *condition = NULL; struct lttng_notification_channel *notification_channel = NULL; struct lttng_trigger *ctrl_trigger = NULL, *trigger = NULL; @@ -1102,22 +1134,38 @@ static void test_tracepoint_event_rule_notification_filter( * the filter) and 2 from the control trigger. This works whatever * the order we receive the notifications. */ - for (i = 0; i < 3; i++) { - char *name = get_next_notification_trigger_name( + for (i = 0; i < notification_count; i++) { + const char *name; + struct lttng_notification *notification = get_next_notification( notification_channel); + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + name = get_notification_trigger_name(notification); + if (name == NULL) { + lttng_notification_destroy(notification); + goto end; + } + if (strcmp(ctrl_trigger_name, name) == 0) { ctrl_count++; } else if (strcmp(trigger_name, name) == 0) { count++; } - free(name); + lttng_notification_destroy(notification); } ok(ctrl_count / 2 == count, "Get twice as many control notif as of regular notif"); +end: suspend_application(); lttng_unregister_trigger(trigger); @@ -1137,6 +1185,7 @@ static void test_tracepoint_event_rule_notification_exclusion( struct lttng_notification_channel *notification_channel = NULL; struct lttng_trigger *ctrl_trigger = NULL, *trigger = NULL; int ctrl_count = 0, count = 0, i; + const int notification_count = 6; const char * const ctrl_trigger_name = "control_exclusion_trigger"; const char * const trigger_name = "exclusion_trigger"; const char * const pattern = "tp:tptest*"; @@ -1184,22 +1233,38 @@ static void test_tracepoint_event_rule_notification_exclusion( * the exclusion) and 5 from the control trigger. This works whatever * the order we receive the notifications. */ - for (i = 0; i < 6; i++) { - char *name = get_next_notification_trigger_name( + for (i = 0; i < notification_count; i++) { + const char *name; + struct lttng_notification *notification = get_next_notification( notification_channel); + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + name = get_notification_trigger_name(notification); + if (name == NULL) { + lttng_notification_destroy(notification); + goto end; + } + if (strcmp(ctrl_trigger_name, name) == 0) { ctrl_count++; } else if (strcmp(trigger_name, name) == 0) { count++; } - free(name); + lttng_notification_destroy(notification); } ok(ctrl_count / 5 == count, "Got 5 times as many control notif as of regular notif"); +end: suspend_application(); lttng_unregister_trigger(trigger); @@ -1286,13 +1351,22 @@ static void test_kprobe_event_rule_notification( resume_application(); for (i = 0; i < notification_count; i++) { - char *name = get_next_notification_trigger_name( + struct lttng_notification *notification = get_next_notification( notification_channel); - ok(strcmp(trigger_name, name) == 0, - "Received notification for the expected trigger name: '%s' (%d/%d)", - trigger_name, i + 1, notification_count); - free(name); + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + ret = validator_notification_trigger_name(notification, trigger_name); + lttng_notification_destroy(notification); + if (ret) { + goto end; + } } end: @@ -1390,14 +1464,23 @@ static void test_uprobe_event_rule_notification( resume_application(); - for (i = 0; i < notification_count; i++) { - char *name = get_next_notification_trigger_name( + for (i = 0; i < 3; i++) { + struct lttng_notification *notification = get_next_notification( notification_channel); - ok(strcmp(trigger_name, name) == 0, - "Received notification for the expected trigger name: '%s' (%d/%d)", - trigger_name, i + 1, notification_count); - free(name); + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + ret = validator_notification_trigger_name(notification, trigger_name); + lttng_notification_destroy(notification); + if (ret) { + goto end; + } } end: suspend_application(); @@ -1406,6 +1489,7 @@ end: lttng_unregister_trigger(trigger); lttng_trigger_destroy(trigger); lttng_action_destroy(action); + lttng_userspace_probe_location_destroy(probe_location); lttng_event_rule_destroy(event_rule); lttng_condition_destroy(condition); return; @@ -1473,13 +1557,22 @@ static void test_syscall_event_rule_notification( resume_application(); for (i = 0; i < notification_count; i++) { - char *name = get_next_notification_trigger_name( + struct lttng_notification *notification = get_next_notification( notification_channel); - ok(strcmp(trigger_name, name) == 0, - "Received notification for the expected trigger name: '%s' (%d/%d)", - trigger_name, i + 1, notification_count); - free(name); + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + ret = validator_notification_trigger_name(notification, trigger_name); + lttng_notification_destroy(notification); + if (ret) { + goto end; + } } end: suspend_application(); @@ -1491,6 +1584,103 @@ end: return; } +static void test_syscall_event_rule_notification_filter( + enum lttng_domain_type domain_type) +{ + int i, ret; + const int notification_count = 3; + enum lttng_notification_channel_status nc_status; + enum lttng_event_rule_status event_rule_status; + enum lttng_trigger_status trigger_status; + struct lttng_notification_channel *notification_channel = NULL; + struct lttng_condition *condition = NULL; + struct lttng_event_rule *event_rule = NULL; + struct lttng_action *action = NULL; + struct lttng_trigger *trigger = NULL; + const char * const trigger_name = "syscall_trigger"; + const char * const syscall_name = "openat"; + const char * const filter_pattern = "filename == \"/proc/cpuinfo\""; + + action = lttng_action_notify_create(); + if (!action) { + fail("Failed to create notify action"); + goto end; + } + + notification_channel = lttng_notification_channel_create( + lttng_session_daemon_notification_endpoint); + ok(notification_channel, "Notification channel object creation"); + + event_rule = lttng_event_rule_syscall_create(); + ok(event_rule, "syscall event rule object creation"); + + event_rule_status = lttng_event_rule_syscall_set_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, filter_pattern); + ok(event_rule_status == LTTNG_EVENT_RULE_STATUS_OK, + "Setting filter: '%s'", filter_pattern); + + condition = lttng_condition_event_rule_create(event_rule); + ok(condition, "Condition event rule object creation"); + + /* Register the triggers for condition */ + trigger = lttng_trigger_create(condition, action); + if (!trigger) { + fail("Failed to create trigger with syscall filtering event rule condition and notify action"); + goto end; + } + + trigger_status = lttng_trigger_set_name(trigger, trigger_name); + ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, + "Setting name to trigger '%s'", trigger_name); + + ret = lttng_register_trigger(trigger); + if (ret) { + fail("Failed to register trigger with syscall filtering event rule condition and notify action"); + goto end; + } + + nc_status = lttng_notification_channel_subscribe( + notification_channel, condition); + ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK, + "Subscribe to tracepoint event rule condition"); + + resume_application(); + + for (i = 0; i < notification_count; i++) { + struct lttng_notification *notification = get_next_notification( + notification_channel); + + ok(notification, "Received notification (%d/%d)", i + 1, + notification_count); + + /* Error. */ + if (notification == NULL) { + goto end; + } + + ret = validator_notification_trigger_name(notification, trigger_name); + lttng_notification_destroy(notification); + if (ret) { + goto end; + } + } + +end: + suspend_application(); + + lttng_unregister_trigger(trigger); + lttng_notification_channel_destroy(notification_channel); + lttng_trigger_destroy(trigger); + lttng_event_rule_destroy(event_rule); + lttng_condition_destroy(condition); + return; +} + int main(int argc, const char *argv[]) { int test_scenario; @@ -1527,7 +1717,7 @@ int main(int argc, const char *argv[]) switch (test_scenario) { case 1: { - plan_tests(38); + plan_tests(44); /* Test cases that need gen-ust-event testapp. */ diag("Test basic notification error paths for %s domain", @@ -1546,6 +1736,7 @@ int main(int argc, const char *argv[]) case 2: { const char *session_name, *channel_name; + /* Test cases that need a tracing session enabled. */ plan_tests(99); @@ -1592,7 +1783,7 @@ int main(int argc, const char *argv[]) * Test cases that need a test app with more than one event * type. */ - plan_tests(19); + plan_tests(25); /* * At the moment, the only test case of this scenario is @@ -1607,8 +1798,7 @@ int main(int argc, const char *argv[]) } case 4: { - plan_tests(10); - + plan_tests(13); /* Test cases that need the kernel tracer. */ assert(domain_type == LTTNG_DOMAIN_KERNEL); @@ -1621,7 +1811,7 @@ int main(int argc, const char *argv[]) } case 5: { - plan_tests(10); + plan_tests(25); /* Test cases that need the kernel tracer. */ assert(domain_type == LTTNG_DOMAIN_KERNEL); @@ -1630,13 +1820,18 @@ int main(int argc, const char *argv[]) test_syscall_event_rule_notification(domain_type); + diag("Test syscall filtering event rule notifications for domain %s", + domain_type_string); + + test_syscall_event_rule_notification_filter(domain_type); + break; } case 6: { const char *testapp_path, *test_symbol_name; - plan_tests(10); + plan_tests(13); if (argc < 7) { fail("Missing parameter for tests to run %d", argc);