relayd: track stdio output file descriptors

[lttng-tools.git] / src / bin / lttng-relayd / main.c

diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c
index 6234e3e170d92515d1255a15087906531369083a..16bfccbfa0c982cd3c7fcd33c0ed1ea0999369cf 100644 (file)
--- a/src/bin/lttng-relayd/main.c
+++ b/src/bin/lttng-relayd/main.c
@@ -664,7 +664,10 @@ static void relayd_cleanup(void)
                health_app_destroy(health_relayd);
        }
        /* Close thread quit pipes */
-       utils_close_pipe(health_quit_pipe);
+       if (health_quit_pipe[0] != -1) {
+               (void) fd_tracker_util_pipe_close(
+                               the_fd_tracker, health_quit_pipe);
+       }
        if (thread_quit_pipe[0] != -1) {
                (void) fd_tracker_util_pipe_close(
                                the_fd_tracker, thread_quit_pipe);
@@ -674,6 +677,11 @@ static void relayd_cleanup(void)
                                sessiond_trace_chunk_registry);
        }
        if (the_fd_tracker) {
+               untrack_stdio();
+               /*
+                * fd_tracker_destroy() will log the contents of the fd-tracker
+                * if a leak is detected.
+                */
                fd_tracker_destroy(the_fd_tracker);
        }
 
@@ -684,7 +692,6 @@ static void relayd_cleanup(void)
        if (tracing_group_name_override) {
                free((void *) tracing_group_name);
        }
-       fd_tracker_log(the_fd_tracker);
 }
 
 /*
@@ -842,10 +849,22 @@ static int init_thread_quit_pipe(void)
                        the_fd_tracker, "Quit pipe", thread_quit_pipe);
 }
 
+/*
+ * Init health quit pipe.
+ *
+ * Return -1 on error or 0 if all pipes are created.
+ */
+static int init_health_quit_pipe(void)
+{
+       return fd_tracker_util_pipe_open_cloexec(the_fd_tracker,
+                       "Health quit pipe", health_quit_pipe);
+}
+
 /*
  * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
  */
-static int create_thread_poll_set(struct lttng_poll_event *events, int size)
+static int create_named_thread_poll_set(struct lttng_poll_event *events,
+               int size, const char *name)
 {
        int ret;
 
@@ -854,10 +873,8 @@ static int create_thread_poll_set(struct lttng_poll_event *events, int size)
                goto error;
        }
 
-       ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
-       if (ret < 0) {
-               goto error;
-       }
+       ret = fd_tracker_util_poll_create(the_fd_tracker,
+                       name, events, 1, LTTNG_CLOEXEC);
 
        /* Add quit pipe */
        ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN | LPOLLERR);
@@ -956,7 +973,7 @@ static void *relay_thread_listener(void *data)
         * Pass 3 as size here for the thread quit pipe, control and
         * data socket.
         */
-       ret = create_thread_poll_set(&events, 3);
+       ret = create_named_thread_poll_set(&events, 3, "Listener thread epoll");
        if (ret < 0) {
                goto error_create_poll;
        }
@@ -1090,7 +1107,7 @@ exit:
 error:
 error_poll_add:
 error_testpoint:
-       lttng_poll_clean(&events);
+       (void) fd_tracker_util_poll_clean(the_fd_tracker, &events);
 error_create_poll:
        if (data_sock->fd >= 0) {
                ret = data_sock->ops->close(data_sock);
@@ -3673,7 +3690,7 @@ static void *relay_thread_worker(void *data)
                goto relay_connections_ht_error;
        }
 
-       ret = create_thread_poll_set(&events, 2);
+       ret = create_named_thread_poll_set(&events, 2, "Worker thread epoll");
        if (ret < 0) {
                goto error_poll_create;
        }
@@ -3942,12 +3959,13 @@ error:
        }
        rcu_read_unlock();
 
-       lttng_poll_clean(&events);
+       (void) fd_tracker_util_poll_clean(the_fd_tracker, &events);
 error_poll_create:
        lttng_ht_destroy(relay_connections_ht);
 relay_connections_ht_error:
        /* Close relay conn pipes */
-       utils_close_pipe(relay_conn_pipe);
+       (void) fd_tracker_util_pipe_close(the_fd_tracker,
+                       relay_conn_pipe);
        if (err) {
                DBG("Thread exited with error");
        }
@@ -3969,11 +3987,41 @@ error_testpoint:
  */
 static int create_relay_conn_pipe(void)
 {
-       int ret;
+       return fd_tracker_util_pipe_open_cloexec(the_fd_tracker,
+                       "Relayd connection pipe", relay_conn_pipe);
+}
 
-       ret = utils_create_pipe_cloexec(relay_conn_pipe);
+static int stdio_open(void *data, int *fds)
+{
+       fds[0] = fileno(stdout);
+       fds[1] = fileno(stderr);
+       return 0;
+}
 
-       return ret;
+static int noop_close(void *data, int *fds)
+{
+       return 0;
+}
+
+static int track_stdio(void)
+{
+       int fds[2];
+       const char *names[] = { "stdout", "stderr" };
+
+       return fd_tracker_open_unsuspendable_fd(the_fd_tracker, fds,
+                       names, 2, stdio_open, NULL);
+}
+
+static void untrack_stdio(void)
+{
+       int fds[] = { fileno(stdout), fileno(stderr) };
+
+       /*
+        * noop_close is used since we don't really want to close
+        * the stdio output fds; we merely want to stop tracking them.
+        */
+       (void) fd_tracker_close_unsuspendable_fd(the_fd_tracker,
+                       fds, 2, noop_close, NULL);
 }
 
 /*
@@ -4080,6 +4128,12 @@ int main(int argc, char **argv)
                goto exit_options;
        }
 
+       ret = track_stdio();
+       if (ret) {
+               retval = -1;
+               goto exit_options;
+       }
+
        /* Initialize thread health monitoring */
        health_relayd = health_app_create(NR_HEALTH_RELAYD_TYPES);
        if (!health_relayd) {
@@ -4128,7 +4182,7 @@ int main(int argc, char **argv)
                goto exit_options;
        }
 
-       ret = utils_create_pipe(health_quit_pipe);
+       ret = init_health_quit_pipe();
        if (ret) {
                retval = -1;
                goto exit_options;