int main(int argc, const char *argv[])
{
int ret = 0;
struct session session = { 0 };
struct lttng_notification_channel *notification_channel = NULL;
struct lttng_rotation_handle *rotation_handle = NULL;
enum lttng_rotation_status rotation_status;
enum lttng_rotation_state rotation_state =
LTTNG_ROTATION_STATE_NO_ROTATION;
if (argc != 3) {
puts("Usage: rotation SESSION_NAME SESSION_OUTPUT_PATH");
ret = 1;
goto error;
}
session.name = argv[1];
session.output_path = argv[2];
plan_tests(TEST_COUNT);
notification_channel = lttng_notification_channel_create(
lttng_session_daemon_notification_endpoint);
if (!notification_channel) {
diag("Failed to create notification channel");
ret = -1;
goto error;
}
ret = setup_rotation_trigger(&session, notification_channel);
if (ret) {
goto error;
}
/* Start rotation and wait for its completion. */
ret = lttng_rotate_session(session.name, NULL, &rotation_handle);
ok(ret >= 0 && rotation_handle, "Start rotation of session \"%s\"",
session.name);
if (ret < 0 || !rotation_handle) {
goto error;
}
do {
rotation_status = lttng_rotation_handle_get_state(
rotation_handle, &rotation_state);
} while (rotation_state == LTTNG_ROTATION_STATE_ONGOING &&
rotation_status == LTTNG_ROTATION_STATUS_OK);
ok(rotation_status == LTTNG_ROTATION_STATUS_OK &&
rotation_state == LTTNG_ROTATION_STATE_COMPLETED,
"Complete rotation of session \"%s\"", session.name);
/*
* After a rotation has completed, we can expect two notifications to
* be queued:
* - Session rotation ongoing
* - Session rotation completed
*/
ret = test_rotation_ongoing_notification(notification_channel,
&session);
if (ret) {
goto error;
}
ret = test_rotation_completed_notification(notification_channel,
&session);
if (ret) {
goto error;
}
error:
lttng_notification_channel_destroy(notification_channel);
lttng_rotation_handle_destroy(rotation_handle);
return ret;
}
int main(int argc, char **argv)
{
int ret = 0;
enum lttng_condition_status condition_status;
enum lttng_notification_channel_status nc_status;
struct lttng_notification_channel *notification_channel = NULL;
struct lttng_condition *condition = NULL;
struct lttng_action *action = NULL;
struct lttng_trigger *trigger = NULL;
/*
* Disable buffering on stdout.
* Safety measure to prevent hang on the validation side since
* stdout is used for outside synchronization.
*/
setbuf(stdout, NULL);
if (argc < 8) {
printf("error: Missing arguments for tests\n");
ret = 1;
goto end;
}
ret = parse_arguments(argv);
if (ret) {
printf("error: Could not parse arguments\n");
goto end;
}
/* Setup */
notification_channel = lttng_notification_channel_create(
lttng_session_daemon_notification_endpoint);
if (!notification_channel) {
printf("error: Could not create notification channel\n");
ret = 1;
goto end;
}
switch (buffer_usage_type) {
case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
condition = lttng_condition_buffer_usage_low_create();
break;
case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
condition = lttng_condition_buffer_usage_high_create();
break;
default:
printf("error: Invalid buffer_usage_type\n");
ret = 1;
goto end;
}
if (!condition) {
printf("error: Could not create condition object\n");
ret = 1;
goto end;
}
if (is_threshold_ratio) {
condition_status = lttng_condition_buffer_usage_set_threshold_ratio(
condition, threshold_ratio);
} else {
condition_status = lttng_condition_buffer_usage_set_threshold(
condition, threshold_bytes);
}
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
printf("error: Could not set threshold\n");
ret = 1;
goto end;
}
condition_status = lttng_condition_buffer_usage_set_session_name(
condition, session_name);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
printf("error: Could not set session name\n");
ret = 1;
goto end;
}
condition_status = lttng_condition_buffer_usage_set_channel_name(
condition, channel_name);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
printf("error: Could not set channel name\n");
ret = 1;
goto end;
}
condition_status = lttng_condition_buffer_usage_set_domain_type(
condition, domain_type);
if (condition_status != LTTNG_CONDITION_STATUS_OK) {
printf("error: Could not set domain type\n");
ret = 1;
goto end;
}
action = lttng_action_notify_create();
if (!action) {
printf("error: Could not create action notify\n");
ret = 1;
goto end;
}
trigger = lttng_trigger_create(condition, action);
if (!trigger) {
printf("error: Could not create trigger\n");
ret = 1;
goto end;
}
ret = lttng_register_trigger(trigger);
/*
* An equivalent trigger might already be registered if an other app
* registered an equivalent trigger.
*/
if (ret < 0 && ret != -LTTNG_ERR_TRIGGER_EXISTS) {
printf("error: %s\n", lttng_strerror(ret));
ret = 1;
goto end;
}
nc_status = lttng_notification_channel_subscribe(notification_channel, condition);
if (nc_status != LTTNG_NOTIFICATION_CHANNEL_STATUS_OK) {
printf("error: Could not subscribe\n");
ret = 1;
goto end;
}
/* Tell outside process that the client is ready */
printf("sync: ready\n");
for (;;) {
struct lttng_notification *notification;
enum lttng_notification_channel_status status;
const struct lttng_evaluation *notification_evaluation;
const struct lttng_condition *notification_condition;
if (nr_notifications == nr_expected_notifications) {
ret = 0;
goto end;
}
/* Receive the next notification. */
status = lttng_notification_channel_get_next_notification(
notification_channel,
¬ification);
switch (status) {
case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK:
break;
case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED:
ret = 1;
printf("error: No drop should be observed during this test app\n");
goto end;
case LTTNG_NOTIFICATION_CHANNEL_STATUS_CLOSED:
/*
* The notification channel has been closed by the
* session daemon. This is typically caused by a session
* daemon shutting down (cleanly or because of a crash).
*/
printf("error: Notification channel was closed\n");
ret = 1;
goto end;
default:
/* Unhandled conditions / errors. */
printf("error: Unknown notification channel status\n");
ret = 1;
goto end;
}
notification_condition = lttng_notification_get_condition(notification);
notification_evaluation = lttng_notification_get_evaluation(notification);
ret = handle_condition(notification_condition, notification_evaluation);
nr_notifications++;
lttng_notification_destroy(notification);
if (ret != 0) {
goto end;
}
}
end:
if (trigger) {
lttng_unregister_trigger(trigger);
}
if (lttng_notification_channel_unsubscribe(notification_channel, condition)) {
printf("error: channel unsubscribe error\n");
}
lttng_trigger_destroy(trigger);
lttng_condition_destroy(condition);
lttng_action_destroy(action);
lttng_notification_channel_destroy(notification_channel);
printf("exit: %d\n", ret);
return ret;
}
struct lttng_notification_channel *lttng_notification_channel_create(
struct lttng_endpoint *endpoint)
{
int fd, ret;
bool is_in_tracing_group = false, is_root = false;
char *sock_path = NULL;
struct lttng_notification_channel *channel = NULL;
if (!endpoint ||
endpoint != lttng_session_daemon_notification_endpoint) {
goto end;
}
sock_path = zmalloc(LTTNG_PATH_MAX);
if (!sock_path) {
goto end;
}
channel = zmalloc(sizeof(struct lttng_notification_channel));
if (!channel) {
goto end;
}
channel->socket = -1;
pthread_mutex_init(&channel->lock, NULL);
lttng_dynamic_buffer_init(&channel->reception_buffer);
CDS_INIT_LIST_HEAD(&channel->pending_notifications.list);
is_root = (getuid() == 0);
if (!is_root) {
is_in_tracing_group = lttng_check_tracing_group();
}
if (is_root || is_in_tracing_group) {
lttng_ctl_copy_string(sock_path,
DEFAULT_GLOBAL_NOTIFICATION_CHANNEL_UNIX_SOCK,
LTTNG_PATH_MAX);
ret = lttcomm_connect_unix_sock(sock_path);
if (ret >= 0) {
fd = ret;
goto set_fd;
}
}
/* Fallback to local session daemon. */
ret = snprintf(sock_path, LTTNG_PATH_MAX,
DEFAULT_HOME_NOTIFICATION_CHANNEL_UNIX_SOCK,
utils_get_home_dir());
if (ret < 0 || ret >= LTTNG_PATH_MAX) {
goto error;
}
ret = lttcomm_connect_unix_sock(sock_path);
if (ret < 0) {
goto error;
}
fd = ret;
set_fd:
channel->socket = fd;
ret = handshake(channel);
if (ret) {
goto error;
}
end:
free(sock_path);
return channel;
error:
lttng_notification_channel_destroy(channel);
channel = NULL;
goto end;
}