X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fnotification-thread.c;h=b42b282e10cfbc98e262eca77ad6fd6dbeac1213;hp=b580faa2682e1fa7a3a632fc095d93af3ef41b5d;hb=4a91420cefb94afc4a20042bdbe2564086dad3cb;hpb=74df9916833ae6a69520c1a49ddce44ba3eea078 diff --git a/src/bin/lttng-sessiond/notification-thread.c b/src/bin/lttng-sessiond/notification-thread.c index b580faa26..b42b282e1 100644 --- a/src/bin/lttng-sessiond/notification-thread.c +++ b/src/bin/lttng-sessiond/notification-thread.c @@ -37,6 +37,7 @@ #include "notification-thread-commands.h" #include "lttng-sessiond.h" #include "health-sessiond.h" +#include "thread.h" #include #include @@ -54,17 +55,13 @@ void notification_thread_handle_destroy( goto end; } - if (handle->cmd_queue.event_fd < 0) { - goto end; - } - ret = close(handle->cmd_queue.event_fd); - if (ret < 0) { - PERROR("close notification command queue event_fd"); - } - assert(cds_list_empty(&handle->cmd_queue.list)); pthread_mutex_destroy(&handle->cmd_queue.lock); + sem_destroy(&handle->ready); + if (handle->cmd_queue.event_pipe) { + lttng_pipe_destroy(handle->cmd_queue.event_pipe); + } if (handle->channel_monitoring_pipes.ust32_consumer >= 0) { ret = close(handle->channel_monitoring_pipes.ust32_consumer); if (ret) { @@ -94,18 +91,24 @@ struct notification_thread_handle *notification_thread_handle_create( { int ret; struct notification_thread_handle *handle; + struct lttng_pipe *event_pipe = NULL; handle = zmalloc(sizeof(*handle)); if (!handle) { goto end; } - /* FIXME Replace eventfd by a pipe to support older kernels. */ - handle->cmd_queue.event_fd = eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE); - if (handle->cmd_queue.event_fd < 0) { - PERROR("eventfd notification command queue"); + sem_init(&handle->ready, 0, 0); + + event_pipe = lttng_pipe_open(FD_CLOEXEC); + if (!event_pipe) { + ERR("event_pipe creation"); goto error; } + + handle->cmd_queue.event_pipe = event_pipe; + event_pipe = NULL; + CDS_INIT_LIST_HEAD(&handle->cmd_queue.list); ret = pthread_mutex_init(&handle->cmd_queue.lock, NULL); if (ret) { @@ -145,6 +148,7 @@ struct notification_thread_handle *notification_thread_handle_create( end: return handle; error: + lttng_pipe_destroy(event_pipe); notification_thread_handle_destroy(handle); return NULL; } @@ -236,7 +240,7 @@ int notification_channel_socket_create(void) if (getuid() == 0) { ret = chown(sock_path, 0, - utils_get_group_id(tracing_group_name)); + utils_get_group_id(config.tracing_group_name.value)); if (ret) { ERR("Failed to set the notification channel socket's group"); ret = -1; @@ -282,7 +286,7 @@ int init_poll_set(struct lttng_poll_event *poll_set, ERR("[notification-thread] Failed to add notification channel socket to pollset"); goto error; } - ret = lttng_poll_add(poll_set, handle->cmd_queue.event_fd, + ret = lttng_poll_add(poll_set, lttng_pipe_get_readfd(handle->cmd_queue.event_pipe), LPOLLIN | LPOLLERR); if (ret < 0) { ERR("[notification-thread] Failed to add notification command queue event fd to pollset"); @@ -350,11 +354,21 @@ void fini_thread_state(struct notification_thread_state *state) assert(!ret); } if (state->channels_ht) { - ret = cds_lfht_destroy(state->channels_ht, - NULL); + ret = cds_lfht_destroy(state->channels_ht, NULL); + assert(!ret); + } + if (state->sessions_ht) { + ret = cds_lfht_destroy(state->sessions_ht, NULL); + assert(!ret); + } + /* + * Must be destroyed after all channels have been destroyed. + * See comment in struct lttng_session_trigger_list. + */ + if (state->session_triggers_ht) { + ret = cds_lfht_destroy(state->session_triggers_ht, NULL); assert(!ret); } - if (state->notification_channel_socket >= 0) { notification_channel_socket_destroy( state->notification_channel_socket); @@ -362,6 +376,21 @@ void fini_thread_state(struct notification_thread_state *state) lttng_poll_clean(&state->events); } +static +void mark_thread_as_ready(struct notification_thread_handle *handle) +{ + DBG("Marking notification thread as ready"); + sem_post(&handle->ready); +} + +static +void wait_until_thread_is_ready(struct notification_thread_handle *handle) +{ + DBG("Waiting for notification thread to be ready"); + sem_wait(&handle->ready); + DBG("Notification thread is ready"); +} + static int init_thread_state(struct notification_thread_handle *handle, struct notification_thread_state *state) @@ -403,6 +432,12 @@ int init_thread_state(struct notification_thread_handle *handle, goto error; } + state->session_triggers_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0, + CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); + if (!state->session_triggers_ht) { + goto error; + } + state->channel_state_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); if (!state->channel_state_ht) { @@ -420,12 +455,17 @@ int init_thread_state(struct notification_thread_handle *handle, if (!state->channels_ht) { goto error; } - + state->sessions_ht = cds_lfht_new(DEFAULT_HT_SIZE, + 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); + if (!state->sessions_ht) { + goto error; + } state->triggers_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); if (!state->triggers_ht) { goto error; } + mark_thread_as_ready(handle); end: return 0; error: @@ -473,6 +513,7 @@ end: * This thread services notification channel clients and commands received * from various lttng-sessiond components over a command queue. */ +static void *thread_notification(void *data) { int ret; @@ -497,9 +538,6 @@ void *thread_notification(void *data) goto end; } - /* Ready to handle client connections. */ - sessiond_notify_ready(); - while (true) { int fd_count, i; @@ -544,7 +582,7 @@ void *thread_notification(void *data) ERR("[notification-thread] Unexpected poll events %u for notification socket %i", revents, fd); goto error; } - } else if (fd == handle->cmd_queue.event_fd) { + } else if (fd == lttng_pipe_get_readfd(handle->cmd_queue.event_pipe)) { ret = handle_notification_thread_command(handle, &state); if (ret < 0) { @@ -605,3 +643,37 @@ error: end: return NULL; } + +static +bool shutdown_notification_thread(void *thread_data) +{ + struct notification_thread_handle *handle = thread_data; + + notification_thread_command_quit(handle); + return true; +} + +struct lttng_thread *launch_notification_thread( + struct notification_thread_handle *handle) +{ + struct lttng_thread *thread; + + thread = lttng_thread_create("Notification", + thread_notification, + shutdown_notification_thread, + NULL, + handle); + if (!thread) { + goto error; + } + + /* + * Wait for the thread to be marked as "ready" before returning + * as other subsystems depend on the notification subsystem + * (e.g. rotation thread). + */ + wait_until_thread_is_ready(handle); + return thread; +error: + return NULL; +}