int nb_args = 0;
int named_pipe_args_start = 0;
-pid_t app_pid = -1;
+pid_t app_pid = 0;
const char *app_state_file = NULL;
static
/*
* Send SIGUSR1 to application instructing it to bypass tracepoint.
*/
+ assert(app_pid > 1);
+
ret = kill(app_pid, SIGUSR1);
if (ret) {
fail("SIGUSR1 failed. errno %d", errno);
goto error;
}
+ assert(app_pid > 1);
+
ret = kill(app_pid, SIGUSR1);
if (ret) {
fail("SIGUSR1 failed. errno %d", errno);
}
static
-void test_notification_channel(const char *session_name,
- const char *channel_name,
- const enum lttng_domain_type domain_type,
- const char **argv)
+void test_invalid_channel_subscription(
+ const enum lttng_domain_type domain_type)
{
- int ret = 0;
enum lttng_condition_status condition_status;
enum lttng_notification_channel_status nc_status;
-
- struct lttng_action *action = NULL;
- struct lttng_notification *notification = NULL;
- struct lttng_notification_channel *notification_channel = NULL;
- struct lttng_trigger *trigger = NULL;
-
- struct lttng_condition *low_condition = NULL;
- struct lttng_condition *high_condition = NULL;
- struct lttng_condition *dummy_invalid_condition = NULL;
struct lttng_condition *dummy_condition = NULL;
+ struct lttng_condition *dummy_invalid_condition = NULL;
+ struct lttng_notification_channel *notification_channel = NULL;
+ int ret = 0;
- double low_ratio = 0.0;
- double high_ratio = 0.90;
-
- /* Set-up */
- action = lttng_action_notify_create();
- if (!action) {
- fail("Setup error on action creation");
+ notification_channel = lttng_notification_channel_create(
+ lttng_session_daemon_notification_endpoint);
+ ok(notification_channel, "Notification channel object creation");
+ if (!notification_channel) {
goto end;
}
- /* Create a dummy, empty condition for later test */
+ /*
+ * Create a dummy, empty (thus invalid) condition to test error paths.
+ */
dummy_invalid_condition = lttng_condition_buffer_usage_low_create();
if (!dummy_invalid_condition) {
fail("Setup error on condition creation");
goto end;
}
+ /*
+ * Test subscription and unsubscription of an invalid condition to/from
+ * a channel.
+ */
+ nc_status = lttng_notification_channel_subscribe(
+ notification_channel, dummy_invalid_condition);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
+ "Subscribing to an invalid condition");
+
+ nc_status = lttng_notification_channel_unsubscribe(
+ notification_channel, dummy_invalid_condition);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
+ "Unsubscribing from an invalid condition");
+
/* Create a valid dummy condition with a ratio of 0.5 */
dummy_condition = lttng_condition_buffer_usage_low_create();
if (!dummy_condition) {
fail("Setup error on dummy_condition creation");
goto end;
-
}
+
condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
dummy_condition, 0.5);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
}
ret = setup_buffer_usage_condition(dummy_condition, "dummy_condition",
- session_name, channel_name, domain_type);
+ "dummy_session", "dummy_channel", domain_type);
if (ret) {
fail("Setup error on dummy condition creation");
goto end;
}
- /* Register a low condition with a ratio */
- low_condition = lttng_condition_buffer_usage_low_create();
- if (!low_condition) {
- fail("Setup error on low_condition creation");
- goto end;
+ /*
+ * Test subscription and unsubscription to/from a channel with invalid
+ * parameters.
+ */
+ nc_status = lttng_notification_channel_subscribe(NULL, NULL);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
+ "Notification channel subscription is invalid: NULL, NULL");
+
+ nc_status = lttng_notification_channel_subscribe(
+ notification_channel, NULL);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
+ "Notification channel subscription is invalid: NON-NULL, NULL");
+
+ nc_status = lttng_notification_channel_subscribe(NULL, dummy_condition);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
+ "Notification channel subscription is invalid: NULL, NON-NULL");
+
+ nc_status = lttng_notification_channel_unsubscribe(
+ notification_channel, dummy_condition);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_UNKNOWN_CONDITION,
+ "Unsubscribing from a valid unknown condition");
+
+end:
+ lttng_notification_channel_destroy(notification_channel);
+ lttng_condition_destroy(dummy_invalid_condition);
+ lttng_condition_destroy(dummy_condition);
+ return;
+}
+
+enum buffer_usage_type {
+ BUFFER_USAGE_TYPE_LOW,
+ BUFFER_USAGE_TYPE_HIGH,
+};
+
+static int register_buffer_usage_notify_trigger(const char *session_name,
+ const char *channel_name,
+ const enum lttng_domain_type domain_type,
+ enum buffer_usage_type buffer_usage_type,
+ double ratio,
+ struct lttng_condition **condition,
+ struct lttng_action **action,
+ struct lttng_trigger **trigger)
+{
+ enum lttng_condition_status condition_status;
+ struct lttng_action *tmp_action = NULL;
+ struct lttng_condition *tmp_condition = NULL;
+ struct lttng_trigger *tmp_trigger = NULL;
+ int ret = 0;
+
+ /* Set-up */
+ tmp_action = lttng_action_notify_create();
+ if (!action) {
+ fail("Setup error on action creation");
+ ret = -1;
+ goto error;
+ }
+
+ if (buffer_usage_type == BUFFER_USAGE_TYPE_LOW) {
+ tmp_condition = lttng_condition_buffer_usage_low_create();
+ } else {
+ tmp_condition = lttng_condition_buffer_usage_high_create();
+ }
+
+ if (!tmp_condition) {
+ fail("Setup error on condition creation");
+ ret = -1;
+ goto error;
}
+
+ /* Set the buffer usage threashold */
condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
- low_condition, low_ratio);
+ tmp_condition, ratio);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
- fail("Setup error on low_condition creation");
- goto end;
+ fail("Setup error on condition creation");
+ ret = -1;
+ goto error;
}
- ret = setup_buffer_usage_condition(low_condition, "low_condition",
+ ret = setup_buffer_usage_condition(tmp_condition, "condition_name",
session_name, channel_name, domain_type);
if (ret) {
- fail("Setup error on low condition creation");
- goto end;
+ fail("Setup error on condition creation");
+ ret = -1;
+ goto error;
}
- /* Register a high condition with a ratio */
- high_condition = lttng_condition_buffer_usage_high_create();
- if (!high_condition) {
- fail("Setup error on high_condition creation");
- goto end;
+ /* Register the trigger for condition. */
+ tmp_trigger = lttng_trigger_create(tmp_condition, tmp_action);
+ if (!tmp_trigger) {
+ fail("Setup error on trigger creation");
+ ret = -1;
+ goto error;
}
- condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
- high_condition, high_ratio);
- if (condition_status != LTTNG_CONDITION_STATUS_OK) {
- fail("Setup error on high_condition creation");
- goto end;
+ ret = lttng_register_trigger(tmp_trigger);
+ if (ret) {
+ fail("Setup error on trigger registration");
+ ret = -1;
+ goto error;
}
- ret = setup_buffer_usage_condition(high_condition, "high_condition",
- session_name, channel_name, domain_type);
+ *condition = tmp_condition;
+ *trigger = tmp_trigger;
+ *action = tmp_action;
+ goto end;
+
+error:
+ lttng_action_destroy(tmp_action);
+ lttng_condition_destroy(tmp_condition);
+ lttng_trigger_destroy(tmp_trigger);
+
+end:
+ return ret;
+}
+
+static void test_subscription_twice(const char *session_name,
+ const char *channel_name,
+ const enum lttng_domain_type domain_type)
+{
+ int ret = 0;
+ enum lttng_notification_channel_status nc_status;
+
+ struct lttng_action *action = NULL;
+ struct lttng_notification_channel *notification_channel = NULL;
+ struct lttng_trigger *trigger = NULL;
+
+ struct lttng_condition *condition = NULL;
+
+ ret = register_buffer_usage_notify_trigger(session_name, channel_name,
+ domain_type, BUFFER_USAGE_TYPE_LOW, 0.99, &condition,
+ &action, &trigger);
if (ret) {
- fail("Setup error on high condition creation");
+ fail("Setup error on trigger registration");
goto end;
}
- /* Register the triggers for low and high condition */
- trigger = lttng_trigger_create(low_condition, action);
- if (!trigger) {
- fail("Setup error on low trigger creation");
+ /* Begin testing. */
+ notification_channel = lttng_notification_channel_create(
+ lttng_session_daemon_notification_endpoint);
+ ok(notification_channel, "Notification channel object creation");
+ if (!notification_channel) {
goto end;
}
- ret = lttng_register_trigger(trigger);
- if (ret) {
- fail("Setup error on low trigger registration");
- goto end;
- }
+ /* Subscribe a valid condition. */
+ nc_status = lttng_notification_channel_subscribe(
+ notification_channel, condition);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
+ "Subscribe to condition");
+
+ /* Subscribing again should fail. */
+ nc_status = lttng_notification_channel_subscribe(
+ notification_channel, condition);
+ ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_ALREADY_SUBSCRIBED,
+ "Subscribe to a condition for which subscription was already done");
+end:
+ lttng_unregister_trigger(trigger);
lttng_trigger_destroy(trigger);
- trigger = NULL;
+ lttng_notification_channel_destroy(notification_channel);
+ lttng_action_destroy(action);
+ lttng_condition_destroy(condition);
+}
+
+static void test_buffer_usage_notification_channel(const char *session_name,
+ const char *channel_name,
+ const enum lttng_domain_type domain_type,
+ const char **argv)
+{
+ int ret = 0;
+ enum lttng_notification_channel_status nc_status;
+
+ struct lttng_action *low_action = NULL;
+ struct lttng_action *high_action = NULL;
+ struct lttng_notification *notification = NULL;
+ struct lttng_notification_channel *notification_channel = NULL;
+ struct lttng_trigger *low_trigger = NULL;
+ struct lttng_trigger *high_trigger = NULL;
- trigger = lttng_trigger_create(high_condition, action);
- if (!trigger) {
- fail("Setup error on high trigger creation");
+ struct lttng_condition *low_condition = NULL;
+ struct lttng_condition *high_condition = NULL;
+
+ const double low_ratio = 0.0;
+ const double high_ratio = 0.90;
+
+ ret = register_buffer_usage_notify_trigger(session_name, channel_name,
+ domain_type, BUFFER_USAGE_TYPE_LOW, low_ratio,
+ &low_condition, &low_action, &low_trigger);
+ if (ret) {
+ fail("Setup error on low trigger registration");
goto end;
}
- ret = lttng_register_trigger(trigger);
+ ret = register_buffer_usage_notify_trigger(session_name, channel_name,
+ domain_type, BUFFER_USAGE_TYPE_HIGH, high_ratio,
+ &high_condition, &high_action, &high_trigger);
if (ret) {
fail("Setup error on high trigger registration");
goto end;
goto end;
}
- /* Basic error path check */
- nc_status = lttng_notification_channel_subscribe(NULL, NULL);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
- "Notification channel subscription is invalid: NULL, NULL");
-
- nc_status = lttng_notification_channel_subscribe(notification_channel, NULL);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
- "Notification channel subscription is invalid: NON-NULL, NULL");
-
- nc_status = lttng_notification_channel_subscribe(NULL, low_condition);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
- "Notification channel subscription is invalid: NULL, NON-NULL");
-
- nc_status = lttng_notification_channel_subscribe(
- notification_channel, dummy_invalid_condition);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
- "Subscribing to an invalid condition");
-
- nc_status = lttng_notification_channel_unsubscribe(
- notification_channel, dummy_invalid_condition);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_INVALID,
- "Unsubscribing from an invalid condition");
-
- nc_status = lttng_notification_channel_unsubscribe(
- notification_channel, dummy_condition);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_UNKNOWN_CONDITION,
- "Unsubscribing from a valid unknown condition");
-
/* Subscribe a valid low condition */
nc_status = lttng_notification_channel_subscribe(
notification_channel, low_condition);
ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
- "Subscribe to condition");
+ "Subscribe to low condition");
/* Subscribe a valid high condition */
nc_status = lttng_notification_channel_subscribe(
notification_channel, high_condition);
ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_OK,
- "Subscribe to condition");
-
- nc_status = lttng_notification_channel_subscribe(
- notification_channel, low_condition);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_ALREADY_SUBSCRIBED,
- "Subscribe to a condition for which subscription was already done");
+ "Subscribe to high condition");
- nc_status = lttng_notification_channel_subscribe(
- notification_channel, high_condition);
- ok(nc_status == LTTNG_NOTIFICATION_CHANNEL_STATUS_ALREADY_SUBSCRIBED,
- "Subscribe to a condition for which subscription was already done");
+ resume_application();
/* Wait for notification to happen */
stop_consumer(argv);
lttng_notification_destroy(notification);
notification = NULL;
- /* Resume consumer to allow event consumption */
suspend_application();
+
+ /* Resume consumer to allow event consumption */
lttng_stop_tracing_no_wait(session_name);
resume_consumer(argv);
wait_data_pending(session_name);
end:
lttng_notification_channel_destroy(notification_channel);
- lttng_trigger_destroy(trigger);
- lttng_action_destroy(action);
+ lttng_trigger_destroy(low_trigger);
+ lttng_trigger_destroy(high_trigger);
+ lttng_action_destroy(low_action);
+ lttng_action_destroy(high_action);
lttng_condition_destroy(low_condition);
lttng_condition_destroy(high_condition);
- lttng_condition_destroy(dummy_invalid_condition);
- lttng_condition_destroy(dummy_condition);
}
int main(int argc, const char *argv[])
{
+ int test_scenario;
const char *session_name = NULL;
const char *channel_name = NULL;
const char *domain_type_string = NULL;
enum lttng_domain_type domain_type = LTTNG_DOMAIN_NONE;
- plan_tests(NUM_TESTS);
-
- /* Argument 6 and upward are named pipe location for consumerd control */
- named_pipe_args_start = 6;
-
- if (argc < 7) {
- fail("Missing parameter for tests to run %d", argc);
+ if (argc < 3) {
+ fail("Missing test scenario and/or domain type argument(s)");
goto error;
}
- nb_args = argc;
-
- domain_type_string = argv[1];
- session_name = argv[2];
- channel_name = argv[3];
- app_pid = (pid_t) atoi(argv[4]);
- app_state_file = argv[5];
+ test_scenario = atoi(argv[1]);
+ domain_type_string = argv[2];
if (!strcmp("LTTNG_DOMAIN_UST", domain_type_string)) {
domain_type = LTTNG_DOMAIN_UST;
goto error;
}
- diag("Test trigger for domain %s with buffer_usage_low condition", domain_type_string);
- test_triggers_buffer_usage_condition(session_name, channel_name, domain_type, LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW);
- diag("Test trigger for domain %s with buffer_usage_high condition", domain_type_string);
- test_triggers_buffer_usage_condition(session_name, channel_name, domain_type, LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH);
+ switch (test_scenario) {
+ case 1:
+ {
+ plan_tests(7);
+ /* Test cases that need gen-ust-event testapp. */
+ diag("Test basic notification error paths for domain %s",
+ domain_type_string);
+ test_invalid_channel_subscription(domain_type);
+ break;
+ }
+ case 2:
+ {
+ /* Test cases that need a tracing session enabled. */
+ plan_tests(99);
+
+ /*
+ * Argument 7 and upward are named pipe location for consumerd
+ * control.
+ */
+ named_pipe_args_start = 7;
+
+ if (argc < 8) {
+ fail("Missing parameter for tests to run %d", argc);
+ goto error;
+ }
+
+ nb_args = argc;
+
+ session_name = argv[3];
+ channel_name = argv[4];
+ app_pid = (pid_t) atoi(argv[5]);
+ app_state_file = argv[6];
+
+ /*
+ * Test cases are responsible for resuming the app when needed
+ * and making sure it's suspended when returning.
+ */
+ suspend_application();
+
+ test_subscription_twice(session_name, channel_name,
+ domain_type);
+
+ diag("Test trigger for domain %s with buffer_usage_low condition",
+ domain_type_string);
+ test_triggers_buffer_usage_condition(session_name, channel_name,
+ domain_type,
+ LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW);
+
+ diag("Test trigger for domain %s with buffer_usage_high condition",
+ domain_type_string);
+ test_triggers_buffer_usage_condition(session_name, channel_name,
+ domain_type,
+ LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH);
+
+ diag("Test buffer usage notification channel api for domain %s",
+ domain_type_string);
+ test_buffer_usage_notification_channel(session_name, channel_name,
+ domain_type, argv);
+ break;
+ }
+ default:
+ abort();
+ }
- diag("Test notification channel api for domain %s", domain_type_string);
- test_notification_channel(session_name, channel_name, domain_type, argv);
error:
return exit_status();
}
projects / lttng-tools.git / blobdiff