Launch the application notification thread using lttng_thread
authorJérémie Galarneau <jeremie.galarneau@efficios.com>
Tue, 4 Dec 2018 22:37:45 +0000 (17:37 -0500)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Wed, 5 Dec 2018 17:25:11 +0000 (12:25 -0500)
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
src/bin/lttng-sessiond/globals.c
src/bin/lttng-sessiond/lttng-sessiond.h
src/bin/lttng-sessiond/main.c
src/bin/lttng-sessiond/ust-thread.c
src/bin/lttng-sessiond/ust-thread.h

index 82a51512ad4e1dea80cc263a92be347d6aa45765..6ca5a5a712901328d53e078cc0391b42680168d4 100644 (file)
@@ -34,7 +34,6 @@ int kernel_tracer_fd = -1;
 struct lttng_kernel_tracer_version kernel_tracer_version;
 struct lttng_kernel_tracer_abi_version kernel_tracer_abi_version;
 
-int apps_cmd_notify_pipe[2] = { -1, -1 };
 int kernel_poll_pipe[2] = { -1, -1 };
 
 pid_t ppid;
index 243138a9f043311eb611318b0b2d058eda69587f..ae73507620a8b7ea02c7afdc1d75efa6a30c34bc 100644 (file)
@@ -125,12 +125,6 @@ struct ust_reg_wait_node {
        struct cds_list_head head;
 };
 
-/*
- * This pipe is used to inform the thread managing application notify
- * communication that a command is queued and ready to be processed.
- */
-extern int apps_cmd_notify_pipe[2];
-
 /*
  * Used to notify that a hash table needs to be destroyed by dedicated
  * thread. Required by design because we don't want to move destroy
index f1c2cd37cfedf22281f100fc80537259bd3fc32b..39800b51ccba4cefaec88d13e803620da6a02b10 100644 (file)
@@ -142,9 +142,9 @@ static const char *config_ignore_options[] = { "help", "version", "config" };
  * that a command is queued and ready to be processed.
  */
 static int apps_cmd_pipe[2] = { -1, -1 };
+static int apps_cmd_notify_pipe[2] = { -1, -1 };
 
 /* Pthread, Mutexes and Semaphores */
-static pthread_t apps_notify_thread;
 static pthread_t kernel_thread;
 static pthread_t agent_reg_thread;
 static pthread_t load_session_thread;
@@ -293,14 +293,14 @@ static void sessiond_cleanup(void)
         * since we are now called.
         */
        sessiond_close_quit_pipe();
+       utils_close_pipe(apps_cmd_pipe);
+       utils_close_pipe(apps_cmd_notify_pipe);
 
        ret = remove(config.pid_file_path.value);
        if (ret < 0) {
                PERROR("remove pidfile %s", config.pid_file_path.value);
        }
 
-       utils_close_pipe(apps_cmd_pipe);
-
        DBG("Removing sessiond and consumerd content of directory %s",
                config.rundir.value);
 
@@ -2442,13 +2442,8 @@ int main(int argc, char **argv)
        }
 
        /* Create thread to manage application notify socket */
-       ret = pthread_create(&apps_notify_thread, default_pthread_attr(),
-                       ust_thread_manage_notify, (void *) NULL);
-       if (ret) {
-               errno = ret;
-               PERROR("pthread_create notify");
+       if (!launch_application_notification_thread(apps_cmd_notify_pipe[0])) {
                retval = -1;
-               stop_threads();
                goto exit_apps_notify;
        }
 
@@ -2533,13 +2528,6 @@ exit_kernel:
                retval = -1;
        }
 exit_agent_reg:
-
-       ret = pthread_join(apps_notify_thread, &status);
-       if (ret) {
-               errno = ret;
-               PERROR("pthread_join apps notify");
-               retval = -1;
-       }
 exit_apps_notify:
 exit_apps:
 exit_reg_apps:
index 7fb18a782bd2969d3415a2774880c14a60bfaca4..b53b0724184043c5af42f630b4ae584d4ece7495 100644 (file)
 #include "ust-thread.h"
 #include "health-sessiond.h"
 #include "testpoint.h"
+#include "utils.h"
+#include "thread.h"
+
+struct thread_notifiers {
+       struct lttng_pipe *quit_pipe;
+       int apps_cmd_notify_pipe_read_fd;
+};
 
 /*
  * This thread manage application notify communication.
  */
-void *ust_thread_manage_notify(void *data)
+static void *thread_application_notification(void *data)
 {
        int i, ret, pollfd, err = -1;
        ssize_t size_ret;
        uint32_t revents, nb_fd;
        struct lttng_poll_event events;
+       struct thread_notifiers *notifiers = data;
+       const int quit_pipe_read_fd = lttng_pipe_get_readfd(notifiers->quit_pipe);
 
        DBG("[ust-thread] Manage application notify command");
 
@@ -51,18 +60,24 @@ void *ust_thread_manage_notify(void *data)
 
        health_code_update();
 
-       ret = sessiond_set_thread_pollset(&events, 2);
+       ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC);
        if (ret < 0) {
                goto error_poll_create;
        }
 
        /* Add notify pipe to the pollset. */
-       ret = lttng_poll_add(&events, apps_cmd_notify_pipe[0],
+       ret = lttng_poll_add(&events, notifiers->apps_cmd_notify_pipe_read_fd,
                        LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP);
        if (ret < 0) {
                goto error;
        }
 
+       ret = lttng_poll_add(&events, quit_pipe_read_fd,
+                       LPOLLIN | LPOLLERR);
+       if (ret < 0) {
+               goto error;
+       }
+
        health_code_update();
 
        while (1) {
@@ -100,19 +115,16 @@ restart:
                        }
 
                        /* Thread quit pipe has been closed. Killing thread. */
-                       ret = sessiond_check_thread_quit_pipe(pollfd, revents);
-                       if (ret) {
+                       if (pollfd == quit_pipe_read_fd) {
                                err = 0;
                                goto exit;
-                       }
-
-                       /* Inspect the apps cmd pipe */
-                       if (pollfd == apps_cmd_notify_pipe[0]) {
+                       } else if (pollfd == notifiers->apps_cmd_notify_pipe_read_fd) {
+                               /* Inspect the apps cmd pipe */
                                int sock;
 
                                if (revents & LPOLLIN) {
                                        /* Get socket from dispatch thread. */
-                                       size_ret = lttng_read(apps_cmd_notify_pipe[0],
+                                       size_ret = lttng_read(notifiers->apps_cmd_notify_pipe_read_fd,
                                                        &sock, sizeof(sock));
                                        if (size_ret < sizeof(sock)) {
                                                PERROR("read apps notify pipe");
@@ -182,8 +194,7 @@ error:
        lttng_poll_clean(&events);
 error_poll_create:
 error_testpoint:
-       utils_close_pipe(apps_cmd_notify_pipe);
-       apps_cmd_notify_pipe[0] = apps_cmd_notify_pipe[1] = -1;
+
        DBG("Application notify communication apps thread cleanup complete");
        if (err) {
                health_error();
@@ -194,3 +205,52 @@ error_testpoint:
        rcu_unregister_thread();
        return NULL;
 }
+
+static bool shutdown_application_notification_thread(void *data)
+{
+       struct thread_notifiers *notifiers = data;
+       const int write_fd = lttng_pipe_get_writefd(notifiers->quit_pipe);
+
+       return notify_thread_pipe(write_fd) == 1;
+}
+
+static void cleanup_application_notification_thread(void *data)
+{
+       struct thread_notifiers *notifiers = data;
+
+       lttng_pipe_destroy(notifiers->quit_pipe);
+       free(notifiers);
+}
+
+bool launch_application_notification_thread(int apps_cmd_notify_pipe_read_fd)
+{
+       struct lttng_thread *thread;
+       struct thread_notifiers *notifiers;
+       struct lttng_pipe *quit_pipe;
+
+       notifiers = zmalloc(sizeof(*notifiers));
+       if (!notifiers) {
+               goto error;
+       }
+       notifiers->apps_cmd_notify_pipe_read_fd = apps_cmd_notify_pipe_read_fd;
+
+       quit_pipe = lttng_pipe_open(FD_CLOEXEC);
+       if (!quit_pipe) {
+               goto error;
+       }
+       notifiers->quit_pipe = quit_pipe;
+
+       thread = lttng_thread_create("Application notification",
+                       thread_application_notification,
+                       shutdown_application_notification_thread,
+                       cleanup_application_notification_thread,
+                       notifiers);
+       if (!thread) {
+               goto error;
+       }
+       lttng_thread_put(thread);
+       return true;
+error:
+       cleanup_application_notification_thread(notifiers);
+       return false;
+}
index 0292df983d39c4598272d2b5c54b75752daabc97..19cbe4fcd8420a17a1ed4a8f509b836ab92516a9 100644 (file)
 
 #ifdef HAVE_LIBLTTNG_UST_CTL
 
-void *ust_thread_manage_notify(void *data);
+bool launch_application_notification_thread(int apps_cmd_notify_pipe_read_fd);
 
 #else /* HAVE_LIBLTTNG_UST_CTL */
 
-void *ust_thread_manage_notify(void *data)
+bool launch_application_notification_thread(int apps_cmd_notify_pipe_read_fd)
 {
-       return NULL;
+       return true;
 }
 
 #endif /* HAVE_LIBLTTNG_UST_CTL */
This page took 0.044893 seconds and 5 git commands to generate.