#include <common/buffer-view.h>
#include <common/string-utils/format.h>
#include <common/fd-tracker/fd-tracker.h>
+#include <common/fd-tracker/utils.h>
#include "backward-compatibility-group-by.h"
#include "cmd.h"
health_app_destroy(health_relayd);
}
/* Close thread quit pipes */
- utils_close_pipe(health_quit_pipe);
- utils_close_pipe(thread_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);
+ }
if (sessiond_trace_chunk_registry) {
sessiond_trace_chunk_registry_destroy(
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);
}
if (tracing_group_name_override) {
free((void *) tracing_group_name);
}
- fd_tracker_log(the_fd_tracker);
}
/*
*/
static int init_thread_quit_pipe(void)
{
- int ret;
-
- ret = utils_create_pipe_cloexec(thread_quit_pipe);
+ return fd_tracker_util_pipe_open_cloexec(
+ the_fd_tracker, "Quit pipe", thread_quit_pipe);
+}
- return ret;
+/*
+ * 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;
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);
return 0;
}
+static int create_sock(void *data, int *out_fd)
+{
+ int ret;
+ struct lttcomm_sock *sock = data;
+
+ ret = lttcomm_create_sock(sock);
+ if (ret < 0) {
+ goto end;
+ }
+
+ *out_fd = sock->fd;
+end:
+ return ret;
+}
+
+static int close_sock(void *data, int *in_fd)
+{
+ struct lttcomm_sock *sock = data;
+
+ return sock->ops->close(sock);
+}
+
/*
* Create and init socket from uri.
*/
-static struct lttcomm_sock *relay_socket_create(struct lttng_uri *uri)
+static struct lttcomm_sock *relay_socket_create(struct lttng_uri *uri,
+ const char *name)
{
- int ret;
+ int ret, sock_fd;
struct lttcomm_sock *sock = NULL;
+ char uri_str[PATH_MAX];
+ char *formated_name = NULL;
sock = lttcomm_alloc_sock_from_uri(uri);
if (sock == NULL) {
goto error;
}
- ret = lttcomm_create_sock(sock);
- if (ret < 0) {
- goto error;
+ /*
+ * Don't fail to create the socket if the name can't be built as it is
+ * only used for debugging purposes.
+ */
+ ret = uri_to_str_url(uri, uri_str, sizeof(uri_str));
+ uri_str[sizeof(uri_str) - 1] = '\0';
+ if (ret >= 0) {
+ ret = asprintf(&formated_name, "%s socket @ %s", name,
+ uri_str);
+ if (ret < 0) {
+ formated_name = NULL;
+ }
}
- DBG("Listening on sock %d", sock->fd);
+
+ ret = fd_tracker_open_unsuspendable_fd(the_fd_tracker, &sock_fd,
+ (const char **) (formated_name ? &formated_name : NULL),
+ 1, create_sock, sock);
+ free(formated_name);
+ DBG("Listening on %s socket %d", name, sock->fd);
ret = sock->ops->bind(sock);
if (ret < 0) {
health_code_update();
- control_sock = relay_socket_create(control_uri);
+ control_sock = relay_socket_create(control_uri, "Control listener");
if (!control_sock) {
goto error_sock_control;
}
- data_sock = relay_socket_create(data_uri);
+ data_sock = relay_socket_create(data_uri, "Data listener");
if (!data_sock) {
goto error_sock_relay;
}
* 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;
}
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);
+ int data_sock_fd = data_sock->fd;
+
+ ret = fd_tracker_close_unsuspendable_fd(the_fd_tracker,
+ &data_sock_fd, 1, close_sock,
+ data_sock);
if (ret) {
- PERROR("close");
+ PERROR("Failed to close the data listener socket file descriptor");
}
+ data_sock->fd = -1;
}
lttcomm_destroy_sock(data_sock);
error_sock_relay:
if (control_sock->fd >= 0) {
- ret = control_sock->ops->close(control_sock);
+ int control_sock_fd = control_sock->fd;
+
+ ret = fd_tracker_close_unsuspendable_fd(the_fd_tracker,
+ &control_sock_fd, 1, close_sock,
+ control_sock);
if (ret) {
- PERROR("close");
+ PERROR("Failed to close the control listener socket file descriptor");
}
+ control_sock->fd = -1;
}
lttcomm_destroy_sock(control_sock);
error_sock_control:
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;
}
}
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");
}
*/
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);
}
/*
/* Daemonize */
if (opt_daemon || opt_background) {
- int i;
-
ret = lttng_daemonize(&child_ppid, &recv_child_signal,
!opt_background);
if (ret < 0) {
retval = -1;
goto exit_options;
}
-
- /*
- * We are in the child. Make sure all other file
- * descriptors are closed, in case we are called with
- * more opened file descriptors than the standard ones.
- */
- for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
- (void) close(i);
- }
}
if (opt_working_directory) {
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) {
goto exit_options;
}
- ret = utils_create_pipe(health_quit_pipe);
+ ret = init_health_quit_pipe();
if (ret) {
retval = -1;
goto exit_options;