SoW-2020-0002: Trace Hit Counters: trigger error reporting integration
[lttng-tools.git] / src / bin / lttng-sessiond / notification-thread.c
index 3ae8741d65b10a346bec2c965c1581873c8ea155..5a7c0075aa1f24ae72592a1ce7adac61fa9b68e1 100644 (file)
 #include "lttng-sessiond.h"
 #include "health-sessiond.h"
 #include "thread.h"
+#include "testpoint.h"
+
+#include "kernel.h"
+#include <common/kernel-ctl/kernel-ctl.h>
 
 #include <urcu.h>
 #include <urcu/list.h>
 #include <urcu/rculfhash.h>
 
+
+int trigger_consumption_paused;
 /*
  * Destroy the thread data previously created by the init function.
  */
@@ -70,14 +76,21 @@ void notification_thread_handle_destroy(
                        PERROR("close kernel consumer channel monitoring pipe");
                }
        }
+
 end:
        free(handle);
 }
 
+/*
+ * TODO: refactor this if needed. Lifetime of the kernel notification event source.
+ * The kernel_notification_monitor_fd ownwership remain to the main thread.
+ * This is because we need to close this fd before removing the modules.
+ */
 struct notification_thread_handle *notification_thread_handle_create(
                struct lttng_pipe *ust32_channel_monitor_pipe,
                struct lttng_pipe *ust64_channel_monitor_pipe,
-               struct lttng_pipe *kernel_channel_monitor_pipe)
+               struct lttng_pipe *kernel_channel_monitor_pipe,
+               int kernel_notification_monitor_fd)
 {
        int ret;
        struct notification_thread_handle *handle;
@@ -135,6 +148,12 @@ struct notification_thread_handle *notification_thread_handle_create(
        } else {
                handle->channel_monitoring_pipes.kernel_consumer = -1;
        }
+
+       CDS_INIT_LIST_HEAD(&handle->event_trigger_sources.list);
+       ret = pthread_mutex_init(&handle->event_trigger_sources.lock, NULL);
+       if (ret) {
+               goto error;
+       }
 end:
        return handle;
 error:
@@ -305,7 +324,7 @@ int init_poll_set(struct lttng_poll_event *poll_set,
                goto error;
        }
        if (handle->channel_monitoring_pipes.kernel_consumer < 0) {
-               goto end;
+               goto skip_kernel_consumer;
        }
        ret = lttng_poll_add(poll_set,
                        handle->channel_monitoring_pipes.kernel_consumer,
@@ -314,6 +333,8 @@ int init_poll_set(struct lttng_poll_event *poll_set,
                ERR("[notification-thread] Failed to add kernel channel monitoring pipe fd to pollset");
                goto error;
        }
+
+skip_kernel_consumer:
 end:
        return ret;
 error:
@@ -363,6 +384,14 @@ void fini_thread_state(struct notification_thread_state *state)
                ret = cds_lfht_destroy(state->sessions_ht, NULL);
                assert(!ret);
        }
+       if (state->triggers_by_name_uid_ht) {
+               ret = cds_lfht_destroy(state->triggers_by_name_uid_ht, NULL);
+               assert(!ret);
+       }
+       if (state->trigger_tokens_ht) {
+               ret = cds_lfht_destroy(state->trigger_tokens_ht, NULL);
+               assert(!ret);
+       }
        /*
         * Must be destroyed after all channels have been destroyed.
         * See comment in struct lttng_session_trigger_list.
@@ -404,6 +433,7 @@ int init_thread_state(struct notification_thread_handle *handle,
 
        memset(state, 0, sizeof(*state));
        state->notification_channel_socket = -1;
+       state->trigger_id.token_generator = 1;
        lttng_poll_init(&state->events);
 
        ret = notification_channel_socket_create();
@@ -476,7 +506,17 @@ int init_thread_state(struct notification_thread_handle *handle,
        if (!state->triggers_ht) {
                goto error;
        }
+       state->triggers_by_name_uid_ht = cds_lfht_new(DEFAULT_HT_SIZE,
+                       1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
+       if (!state->triggers_by_name_uid_ht) {
+               goto error;
+       }
 
+       state->trigger_tokens_ht = cds_lfht_new(DEFAULT_HT_SIZE,
+                       1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
+       if (!state->trigger_tokens_ht) {
+               goto error;
+       }
        state->executor = action_executor_create(handle);
        if (!state->executor) {
                goto error;
@@ -525,6 +565,63 @@ end:
        return ret;
 }
 
+static int handle_trigger_event_pipe(int fd,
+               enum lttng_domain_type domain,
+               uint32_t revents,
+               struct notification_thread_state *state)
+{
+       int ret = 0;
+
+       if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+               ret = lttng_poll_del(&state->events, fd);
+               if (ret) {
+                       ERR("[notification-thread] Failed to remove event monitoring pipe from poll set");
+               }
+               goto end;
+       }
+
+       if (testpoint(sessiond_handle_trigger_event_pipe)) {
+               ret = 0;
+               goto end;
+       }
+
+       if (caa_unlikely(trigger_consumption_paused)) {
+               DBG("Trigger consumption paused, sleeping...");
+               sleep(1);
+               goto end;
+       }
+
+       ret = handle_notification_thread_event(state, fd, domain);
+       if (ret) {
+               ERR("[notification-thread] Event sample handling error occurred for fd: %d", fd);
+               ret = -1;
+               goto end;
+       }
+
+end:
+       return ret;
+}
+
+/*
+ * Return the event source domain type via parameter.
+ */
+static bool fd_is_event_source(struct notification_thread_handle *handle, int fd, enum lttng_domain_type *domain)
+{
+       struct notification_event_trigger_source_element *source_element, *tmp;
+
+       assert(domain);
+
+       cds_list_for_each_entry_safe(source_element, tmp,
+                       &handle->event_trigger_sources.list, node) {
+               if (source_element->fd != fd) {
+                       continue;
+               }
+               *domain = source_element->domain;
+               return true;
+       }
+       return false;
+}
+
 /*
  * This thread services notification channel clients and commands received
  * from various lttng-sessiond components over a command queue.
@@ -535,6 +632,7 @@ void *thread_notification(void *data)
        int ret;
        struct notification_thread_handle *handle = data;
        struct notification_thread_state state;
+       enum lttng_domain_type domain;
 
        DBG("[notification-thread] Started notification thread");
 
@@ -554,6 +652,10 @@ void *thread_notification(void *data)
                goto end;
        }
 
+       if (testpoint(sessiond_thread_notification)) {
+               goto end;
+       }
+
        while (true) {
                int fd_count, i;
 
@@ -612,6 +714,11 @@ void *thread_notification(void *data)
                                if (ret) {
                                        goto error;
                                }
+                       } else if (fd_is_event_source(handle, fd, &domain)) {
+                               ret = handle_trigger_event_pipe(fd, domain, revents, &state);
+                               if (ret) {
+                                       goto error;
+                               }
                        } else {
                                /* Activity on a client's socket. */
                                if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
This page took 0.036823 seconds and 5 git commands to generate.