* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#define _GNU_SOURCE
#define _LGPL_SOURCE
#include <getopt.h>
#include <grp.h>
#include <sys/wait.h>
#include <urcu/uatomic.h>
#include <unistd.h>
-#include <config.h>
+#include <ctype.h>
#include <common/common.h>
#include <common/compat/socket.h>
#include <common/relayd/relayd.h>
#include <common/utils.h>
#include <common/daemonize.h>
-#include <common/config/config.h>
+#include <common/config/session-config.h>
#include "lttng-sessiond.h"
#include "buffer-registry.h"
#include "agent-thread.h"
#include "save.h"
#include "load-session-thread.h"
+#include "notification-thread.h"
+#include "notification-thread-commands.h"
#include "syscall.h"
#include "agent.h"
+#include "ht-cleanup.h"
#define CONSUMERD_FILE "lttng-consumerd"
+static const char *help_msg =
+#ifdef LTTNG_EMBED_HELP
+#include <lttng-sessiond.8.h>
+#else
+NULL
+#endif
+;
+
const char *progname;
-static const char *tracing_group_name = DEFAULT_TRACING_GROUP;
+const char *tracing_group_name = DEFAULT_TRACING_GROUP;
static int tracing_group_name_override;
static char *opt_pidfile;
static int opt_sig_parent;
.cmd_unix_sock_path = DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
.err_sock = -1,
.cmd_sock = -1,
+ .channel_monitor_pipe = -1,
.pid_mutex = PTHREAD_MUTEX_INITIALIZER,
.lock = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
.cmd_unix_sock_path = DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH,
.err_sock = -1,
.cmd_sock = -1,
+ .channel_monitor_pipe = -1,
.pid_mutex = PTHREAD_MUTEX_INITIALIZER,
.lock = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
.cmd_unix_sock_path = DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH,
.err_sock = -1,
.cmd_sock = -1,
+ .channel_monitor_pipe = -1,
.pid_mutex = PTHREAD_MUTEX_INITIALIZER,
.lock = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
* for all threads when receiving an event on the pipe.
*/
static int thread_quit_pipe[2] = { -1, -1 };
-static int ht_cleanup_quit_pipe[2] = { -1, -1 };
/*
* This pipe is used to inform the thread managing application communication
static pthread_t ht_cleanup_thread;
static pthread_t agent_reg_thread;
static pthread_t load_session_thread;
+static pthread_t notification_thread;
/*
* UST registration command queue. This queue is tied with a futex and uses a N
/* Load session thread information to operate. */
struct load_session_thread_data *load_info;
+/* Notification thread handle. */
+struct notification_thread_handle *notification_thread_handle;
+
/* Global hash tables */
struct lttng_ht *agent_apps_ht_by_sock = NULL;
/*
- * Whether sessiond is ready for commands/health check requests.
+ * Whether sessiond is ready for commands/notification channel/health check
+ * requests.
* NR_LTTNG_SESSIOND_READY must match the number of calls to
* sessiond_notify_ready().
*/
-#define NR_LTTNG_SESSIOND_READY 3
+#define NR_LTTNG_SESSIOND_READY 4
int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
+int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
+{
+ return (fd == thread_quit_pipe[0] && (events & LPOLLIN)) ? 1 : 0;
+}
+
/* Notify parents that we are ready for cmd and health check */
LTTNG_HIDDEN
void sessiond_notify_ready(void)
return __sessiond_set_thread_pollset(events, size, thread_quit_pipe);
}
-/*
- * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
- */
-int sessiond_set_ht_cleanup_thread_pollset(struct lttng_poll_event *events,
- size_t size)
-{
- return __sessiond_set_thread_pollset(events, size,
- ht_cleanup_quit_pipe);
-}
-
-static
-int __sessiond_check_thread_quit_pipe(int fd, uint32_t events, int a_pipe)
-{
- if (fd == a_pipe && (events & LPOLLIN)) {
- return 1;
- }
- return 0;
-}
-
-/*
- * Check if the thread quit pipe was triggered.
- *
- * Return 1 if it was triggered else 0;
- */
-int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
-{
- return __sessiond_check_thread_quit_pipe(fd, events,
- thread_quit_pipe[0]);
-}
-
-/*
- * Check if the ht_cleanup thread quit pipe was triggered.
- *
- * Return 1 if it was triggered else 0;
- */
-int sessiond_check_ht_cleanup_quit(int fd, uint32_t events)
-{
- return __sessiond_check_thread_quit_pipe(fd, events,
- ht_cleanup_quit_pipe[0]);
-}
-
/*
* Init thread quit pipe.
*
return __init_thread_quit_pipe(thread_quit_pipe);
}
-static int init_ht_cleanup_quit_pipe(void)
-{
- return __init_thread_quit_pipe(ht_cleanup_quit_pipe);
-}
-
/*
* Stop all threads by closing the thread quit pipe.
*/
PERROR("UST consumerd64 cmd_sock close");
}
}
+ if (kconsumer_data.channel_monitor_pipe >= 0) {
+ ret = close(kconsumer_data.channel_monitor_pipe);
+ if (ret < 0) {
+ PERROR("kernel consumer channel monitor pipe close");
+ }
+ }
+ if (ustconsumer32_data.channel_monitor_pipe >= 0) {
+ ret = close(ustconsumer32_data.channel_monitor_pipe);
+ if (ret < 0) {
+ PERROR("UST consumerd32 channel monitor pipe close");
+ }
+ }
+ if (ustconsumer64_data.channel_monitor_pipe >= 0) {
+ ret = close(ustconsumer64_data.channel_monitor_pipe);
+ if (ret < 0) {
+ PERROR("UST consumerd64 channel monitor pipe close");
+ }
+ }
}
/*
return ret;
}
+/*
+ * Wait on consumer process termination.
+ *
+ * Need to be called with the consumer data lock held or from a context
+ * ensuring no concurrent access to data (e.g: cleanup).
+ */
+static void wait_consumer(struct consumer_data *consumer_data)
+{
+ pid_t ret;
+ int status;
+
+ if (consumer_data->pid <= 0) {
+ return;
+ }
+
+ DBG("Waiting for complete teardown of consumerd (PID: %d)",
+ consumer_data->pid);
+ ret = waitpid(consumer_data->pid, &status, 0);
+ if (ret == -1) {
+ PERROR("consumerd waitpid pid: %d", consumer_data->pid)
+ } else if (!WIFEXITED(status)) {
+ ERR("consumerd termination with error: %d",
+ WEXITSTATUS(ret));
+ }
+ consumer_data->pid = 0;
+}
+
/*
* Cleanup the session daemon's data structures.
*/
}
}
+ wait_consumer(&kconsumer_data);
+ wait_consumer(&ustconsumer64_data);
+ wait_consumer(&ustconsumer32_data);
+
DBG("Cleaning up all agent apps");
agent_app_ht_clean();
free(kmod_probes_list);
free(kmod_extra_probes_list);
- /* <fun> */
- DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
- "Matthew, BEET driven development works!%c[%dm",
- 27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
- /* </fun> */
+ run_as_destroy_worker();
}
/*
* right amount of memory and copying the original information from the lsm
* structure.
*
- * Return total size of the buffer pointed by buf.
+ * Return 0 on success, negative value on error.
*/
-static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
+static int setup_lttng_msg(struct command_ctx *cmd_ctx,
+ const void *payload_buf, size_t payload_len,
+ const void *cmd_header_buf, size_t cmd_header_len)
{
- int ret, buf_size;
+ int ret = 0;
+ const size_t header_len = sizeof(struct lttcomm_lttng_msg);
+ const size_t cmd_header_offset = header_len;
+ const size_t payload_offset = cmd_header_offset + cmd_header_len;
+ const size_t total_msg_size = header_len + cmd_header_len + payload_len;
- buf_size = size;
+ cmd_ctx->llm = zmalloc(total_msg_size);
- cmd_ctx->llm = zmalloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
if (cmd_ctx->llm == NULL) {
PERROR("zmalloc");
ret = -ENOMEM;
- goto error;
+ goto end;
}
/* Copy common data */
cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
+ cmd_ctx->llm->cmd_header_size = cmd_header_len;
+ cmd_ctx->llm->data_size = payload_len;
+ cmd_ctx->lttng_msg_size = total_msg_size;
- cmd_ctx->llm->data_size = size;
- cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size;
+ /* Copy command header */
+ if (cmd_header_len) {
+ memcpy(((uint8_t *) cmd_ctx->llm) + cmd_header_offset, cmd_header_buf,
+ cmd_header_len);
+ }
- return buf_size;
+ /* Copy payload */
+ if (payload_len) {
+ memcpy(((uint8_t *) cmd_ctx->llm) + payload_offset, payload_buf,
+ payload_len);
+ }
-error:
+end:
return ret;
}
+/*
+ * Version of setup_lttng_msg() without command header.
+ */
+static int setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx,
+ void *payload_buf, size_t payload_len)
+{
+ return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, NULL, 0);
+}
/*
* Update the kernel poll set of all channel fd available over all tracing
* session. Add the wakeup pipe at the end of the set.
}
/* Check for data on kernel pipe */
- if (pollfd == kernel_poll_pipe[0] && (revents & LPOLLIN)) {
- (void) lttng_read(kernel_poll_pipe[0],
- &tmp, 1);
- /*
- * Ret value is useless here, if this pipe gets any actions an
- * update is required anyway.
- */
- update_poll_flag = 1;
- continue;
- } else {
- /*
- * New CPU detected by the kernel. Adding kernel stream to
- * kernel session and updating the kernel consumer
- */
- if (revents & LPOLLIN) {
+ if (revents & LPOLLIN) {
+ if (pollfd == kernel_poll_pipe[0]) {
+ (void) lttng_read(kernel_poll_pipe[0],
+ &tmp, 1);
+ /*
+ * Ret value is useless here, if this pipe gets any actions an
+ * update is required anyway.
+ */
+ update_poll_flag = 1;
+ continue;
+ } else {
+ /*
+ * New CPU detected by the kernel. Adding kernel stream to
+ * kernel session and updating the kernel consumer
+ */
ret = update_kernel_stream(&kconsumer_data, pollfd);
if (ret < 0) {
continue;
}
break;
- /*
- * TODO: We might want to handle the LPOLLERR | LPOLLHUP
- * and unregister kernel stream at this point.
- */
}
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ update_poll_flag = 1;
+ continue;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
}
enum lttcomm_return_code code;
struct lttng_poll_event events;
struct consumer_data *consumer_data = data;
+ struct consumer_socket *cmd_socket_wrapper = NULL;
DBG("[thread] Manage consumer started");
/* Event on the registration socket */
if (pollfd == consumer_data->err_sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ if (revents & LPOLLIN) {
+ continue;
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
ERR("consumer err socket poll error");
goto error;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
}
}
health_code_update();
- if (code == LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) {
- /* Connect both socket, command and metadata. */
- consumer_data->cmd_sock =
- lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
- consumer_data->metadata_fd =
- lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
- if (consumer_data->cmd_sock < 0
- || consumer_data->metadata_fd < 0) {
- PERROR("consumer connect cmd socket");
- /* On error, signal condition and quit. */
- signal_consumer_condition(consumer_data, -1);
- goto error;
- }
- consumer_data->metadata_sock.fd_ptr = &consumer_data->metadata_fd;
- /* Create metadata socket lock. */
- consumer_data->metadata_sock.lock = zmalloc(sizeof(pthread_mutex_t));
- if (consumer_data->metadata_sock.lock == NULL) {
- PERROR("zmalloc pthread mutex");
- ret = -1;
- goto error;
- }
- pthread_mutex_init(consumer_data->metadata_sock.lock, NULL);
-
- signal_consumer_condition(consumer_data, 1);
- DBG("Consumer command socket ready (fd: %d", consumer_data->cmd_sock);
- DBG("Consumer metadata socket ready (fd: %d)",
- consumer_data->metadata_fd);
- } else {
+ if (code != LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) {
ERR("consumer error when waiting for SOCK_READY : %s",
lttcomm_get_readable_code(-code));
goto error;
}
- /* Remove the consumerd error sock since we've established a connexion */
+ /* Connect both command and metadata sockets. */
+ consumer_data->cmd_sock =
+ lttcomm_connect_unix_sock(
+ consumer_data->cmd_unix_sock_path);
+ consumer_data->metadata_fd =
+ lttcomm_connect_unix_sock(
+ consumer_data->cmd_unix_sock_path);
+ if (consumer_data->cmd_sock < 0 || consumer_data->metadata_fd < 0) {
+ PERROR("consumer connect cmd socket");
+ /* On error, signal condition and quit. */
+ signal_consumer_condition(consumer_data, -1);
+ goto error;
+ }
+
+ consumer_data->metadata_sock.fd_ptr = &consumer_data->metadata_fd;
+
+ /* Create metadata socket lock. */
+ consumer_data->metadata_sock.lock = zmalloc(sizeof(pthread_mutex_t));
+ if (consumer_data->metadata_sock.lock == NULL) {
+ PERROR("zmalloc pthread mutex");
+ goto error;
+ }
+ pthread_mutex_init(consumer_data->metadata_sock.lock, NULL);
+
+ DBG("Consumer command socket ready (fd: %d", consumer_data->cmd_sock);
+ DBG("Consumer metadata socket ready (fd: %d)",
+ consumer_data->metadata_fd);
+
+ /*
+ * Remove the consumerd error sock since we've established a connection.
+ */
ret = lttng_poll_del(&events, consumer_data->err_sock);
if (ret < 0) {
goto error;
health_code_update();
+ /*
+ * Transfer the write-end of the channel monitoring pipe to the
+ * by issuing a SET_CHANNEL_MONITOR_PIPE command.
+ */
+ cmd_socket_wrapper = consumer_allocate_socket(&consumer_data->cmd_sock);
+ if (!cmd_socket_wrapper) {
+ goto error;
+ }
+
+ ret = consumer_send_channel_monitor_pipe(cmd_socket_wrapper,
+ consumer_data->channel_monitor_pipe);
+ if (ret) {
+ goto error;
+ }
+ /* Discard the socket wrapper as it is no longer needed. */
+ consumer_destroy_socket(cmd_socket_wrapper);
+ cmd_socket_wrapper = NULL;
+
+ /* The thread is completely initialized, signal that it is ready. */
+ signal_consumer_condition(consumer_data, 1);
+
/* Infinite blocking call, waiting for transmission */
restart_poll:
while (1) {
if (pollfd == sock) {
/* Event on the consumerd socket */
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)
+ && !(revents & LPOLLIN)) {
ERR("consumer err socket second poll error");
goto error;
}
goto exit;
} else if (pollfd == consumer_data->metadata_fd) {
+ if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)
+ && !(revents & LPOLLIN)) {
+ ERR("consumer err metadata socket second poll error");
+ goto error;
+ }
/* UST metadata requests */
ret = ust_consumer_metadata_request(
&consumer_data->metadata_sock);
unlink(consumer_data->err_unix_sock_path);
unlink(consumer_data->cmd_unix_sock_path);
- consumer_data->pid = 0;
pthread_mutex_unlock(&consumer_data->lock);
/* Cleanup metadata socket mutex. */
free(consumer_data->metadata_sock.lock);
}
lttng_poll_clean(&events);
+
+ if (cmd_socket_wrapper) {
+ consumer_destroy_socket(cmd_socket_wrapper);
+ }
error_poll:
if (err) {
health_error();
/* Inspect the apps cmd pipe */
if (pollfd == apps_cmd_pipe[0]) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("Apps command pipe error");
- goto error;
- } else if (revents & LPOLLIN) {
+ if (revents & LPOLLIN) {
int sock;
/* Empty pipe */
health_code_update();
/*
- * We only monitor the error events of the socket. This
- * thread does not handle any incoming data from UST
- * (POLLIN).
+ * Since this is a command socket (write then read),
+ * we only monitor the error events of the socket.
*/
ret = lttng_poll_add(&events, sock,
LPOLLERR | LPOLLHUP | LPOLLRDHUP);
}
DBG("Apps with sock %d added to poll set", sock);
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ ERR("Apps command pipe error");
+ goto error;
+ } else {
+ ERR("Unknown poll events %u for sock %d", revents, pollfd);
+ goto error;
}
} else {
/*
/* Socket closed on remote end. */
ust_app_unregister(pollfd);
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
wait_queue->count--;
ust_app_destroy(wait_node->app);
free(wait_node);
+ /*
+ * Silence warning of use-after-free in
+ * cds_list_for_each_entry_safe which uses
+ * __typeof__(*wait_node).
+ */
+ wait_node = NULL;
break;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
}
.count = 0,
};
+ rcu_register_thread();
+
health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG_DISPATCH);
if (testpoint(sessiond_thread_app_reg_dispatch)) {
* Don't care about return value. Let the manage apps threads
* handle app unregistration upon socket close.
*/
- (void) ust_app_register_done(app->sock);
+ (void) ust_app_register_done(app);
/*
* Even if the application socket has been closed, send the app
free(wait_node);
}
+ /* Empty command queue. */
+ for (;;) {
+ /* Dequeue command for registration */
+ node = cds_wfcq_dequeue_blocking(&ust_cmd_queue.head, &ust_cmd_queue.tail);
+ if (node == NULL) {
+ break;
+ }
+ ust_cmd = caa_container_of(node, struct ust_command, node);
+ ret = close(ust_cmd->sock);
+ if (ret < 0) {
+ PERROR("close ust sock exit dispatch %d", ust_cmd->sock);
+ }
+ lttng_fd_put(LTTNG_FD_APPS, 1);
+ free(ust_cmd);
+ }
+
error_testpoint:
DBG("Dispatch thread dying");
if (err) {
ERR("Health error occurred in %s", __func__);
}
health_unregister(health_sessiond);
+ rcu_unregister_thread();
return NULL;
}
/* Event on the registration socket */
if (pollfd == apps_sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("Register apps socket poll error");
- goto error;
- } else if (revents & LPOLLIN) {
+ if (revents & LPOLLIN) {
sock = lttcomm_accept_unix_sock(apps_sock);
if (sock < 0) {
goto error;
* lttcomm_setsockopt_snd_timeout expect msec as
* parameter.
*/
- (void) lttcomm_setsockopt_rcv_timeout(sock,
- app_socket_timeout * 1000);
- (void) lttcomm_setsockopt_snd_timeout(sock,
- app_socket_timeout * 1000);
+ if (app_socket_timeout >= 0) {
+ (void) lttcomm_setsockopt_rcv_timeout(sock,
+ app_socket_timeout * 1000);
+ (void) lttcomm_setsockopt_snd_timeout(sock,
+ app_socket_timeout * 1000);
+ }
/*
* Set the CLOEXEC flag. Return code is useless because
* barrier with the exchange in cds_wfcq_enqueue.
*/
futex_nto1_wake(&ust_cmd_queue.futex);
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ ERR("Register apps socket poll error");
+ goto error;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
}
int ret, clock_ret;
struct timespec timeout;
- /* Make sure we set the readiness flag to 0 because we are NOT ready */
+ /*
+ * Make sure we set the readiness flag to 0 because we are NOT ready.
+ * This access to consumer_thread_is_ready does not need to be
+ * protected by consumer_data.cond_mutex (yet) since the consumer
+ * management thread has not been started at this point.
+ */
consumer_data->consumer_thread_is_ready = 0;
/* Setup pthread condition */
goto error;
}
- ret = pthread_create(&consumer_data->thread, NULL, thread_manage_consumer,
- consumer_data);
+ ret = pthread_create(&consumer_data->thread, default_pthread_attr(),
+ thread_manage_consumer, consumer_data);
if (ret) {
errno = ret;
PERROR("pthread_create consumer");
pthread_mutex_lock(&consumer_data->cond_mutex);
/* Get time for sem_timedwait absolute timeout */
- clock_ret = clock_gettime(CLOCK_MONOTONIC, &timeout);
+ clock_ret = lttng_clock_gettime(CLOCK_MONOTONIC, &timeout);
/*
* Set the timeout for the condition timed wait even if the clock gettime
* call fails since we might loop on that call and we want to avoid to
DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
+ assert(!rcu_read_ongoing());
+
*sock_error = 0;
switch (cmd_ctx->lsm->cmd_type) {
case LTTNG_SNAPSHOT_RECORD:
case LTTNG_SAVE_SESSION:
case LTTNG_SET_SESSION_SHM_PATH:
+ case LTTNG_REGENERATE_METADATA:
+ case LTTNG_REGENERATE_STATEDUMP:
+ case LTTNG_REGISTER_TRIGGER:
+ case LTTNG_UNREGISTER_TRIGGER:
need_domain = 0;
break;
default:
case LTTNG_LIST_EVENTS:
case LTTNG_LIST_SYSCALLS:
case LTTNG_LIST_TRACKER_PIDS:
+ case LTTNG_DATA_PENDING:
break;
default:
/* Setup lttng message with no payload */
- ret = setup_lttng_msg(cmd_ctx, 0);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0);
if (ret < 0) {
/* This label does not try to unlock the session */
goto init_setup_error;
case LTTNG_CREATE_SESSION:
case LTTNG_CREATE_SESSION_SNAPSHOT:
case LTTNG_CREATE_SESSION_LIVE:
- case LTTNG_CALIBRATE:
case LTTNG_LIST_SESSIONS:
case LTTNG_LIST_TRACEPOINTS:
case LTTNG_LIST_SYSCALLS:
case LTTNG_LIST_TRACEPOINT_FIELDS:
case LTTNG_SAVE_SESSION:
+ case LTTNG_REGISTER_TRIGGER:
+ case LTTNG_UNREGISTER_TRIGGER:
need_tracing_session = 0;
break;
default:
if (cmd_ctx->lsm->cmd_type == LTTNG_START_TRACE ||
cmd_ctx->lsm->cmd_type == LTTNG_STOP_TRACE) {
switch (cmd_ctx->lsm->domain.type) {
+ case LTTNG_DOMAIN_NONE:
+ break;
case LTTNG_DOMAIN_JUL:
case LTTNG_DOMAIN_LOG4J:
case LTTNG_DOMAIN_PYTHON:
goto error;
}
break;
+ default:
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ goto error;
}
}
switch (cmd_ctx->lsm->cmd_type) {
case LTTNG_ADD_CONTEXT:
{
- ret = cmd_add_context(cmd_ctx->session, cmd_ctx->lsm->domain.type,
+ /*
+ * An LTTNG_ADD_CONTEXT command might have a supplementary
+ * payload if the context being added is an application context.
+ */
+ if (cmd_ctx->lsm->u.context.ctx.ctx ==
+ LTTNG_EVENT_CONTEXT_APP_CONTEXT) {
+ char *provider_name = NULL, *context_name = NULL;
+ size_t provider_name_len =
+ cmd_ctx->lsm->u.context.provider_name_len;
+ size_t context_name_len =
+ cmd_ctx->lsm->u.context.context_name_len;
+
+ if (provider_name_len == 0 || context_name_len == 0) {
+ /*
+ * Application provider and context names MUST
+ * be provided.
+ */
+ ret = -LTTNG_ERR_INVALID;
+ goto error;
+ }
+
+ provider_name = zmalloc(provider_name_len + 1);
+ if (!provider_name) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto error;
+ }
+ cmd_ctx->lsm->u.context.ctx.u.app_ctx.provider_name =
+ provider_name;
+
+ context_name = zmalloc(context_name_len + 1);
+ if (!context_name) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto error_add_context;
+ }
+ cmd_ctx->lsm->u.context.ctx.u.app_ctx.ctx_name =
+ context_name;
+
+ ret = lttcomm_recv_unix_sock(sock, provider_name,
+ provider_name_len);
+ if (ret < 0) {
+ goto error_add_context;
+ }
+
+ ret = lttcomm_recv_unix_sock(sock, context_name,
+ context_name_len);
+ if (ret < 0) {
+ goto error_add_context;
+ }
+ }
+
+ /*
+ * cmd_add_context assumes ownership of the provider and context
+ * names.
+ */
+ ret = cmd_add_context(cmd_ctx->session,
+ cmd_ctx->lsm->domain.type,
cmd_ctx->lsm->u.context.channel_name,
- &cmd_ctx->lsm->u.context.ctx, kernel_poll_pipe[1]);
+ &cmd_ctx->lsm->u.context.ctx,
+ kernel_poll_pipe[1]);
+
+ cmd_ctx->lsm->u.context.ctx.u.app_ctx.provider_name = NULL;
+ cmd_ctx->lsm->u.context.ctx.u.app_ctx.ctx_name = NULL;
+error_add_context:
+ free(cmd_ctx->lsm->u.context.ctx.u.app_ctx.provider_name);
+ free(cmd_ctx->lsm->u.context.ctx.u.app_ctx.ctx_name);
+ if (ret < 0) {
+ goto error;
+ }
break;
}
case LTTNG_DISABLE_CHANNEL:
}
case LTTNG_ENABLE_CHANNEL:
{
+ cmd_ctx->lsm->u.channel.chan.attr.extended.ptr =
+ (struct lttng_channel_extended *) &cmd_ctx->lsm->u.channel.extended;
ret = cmd_enable_channel(cmd_ctx->session, &cmd_ctx->lsm->domain,
- &cmd_ctx->lsm->u.channel.chan, kernel_poll_pipe[1]);
+ &cmd_ctx->lsm->u.channel.chan,
+ kernel_poll_pipe[1]);
break;
}
case LTTNG_TRACK_PID:
* Setup lttng message with payload size set to the event list size in
* bytes and then copy list into the llm payload.
*/
- ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_event) * nb_events);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, events,
+ sizeof(struct lttng_event) * nb_events);
+ free(events);
+
if (ret < 0) {
- free(events);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, events,
- sizeof(struct lttng_event) * nb_events);
-
- free(events);
-
ret = LTTNG_OK;
break;
}
* Setup lttng message with payload size set to the event list size in
* bytes and then copy list into the llm payload.
*/
- ret = setup_lttng_msg(cmd_ctx,
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, fields,
sizeof(struct lttng_event_field) * nb_fields);
+ free(fields);
+
if (ret < 0) {
- free(fields);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, fields,
- sizeof(struct lttng_event_field) * nb_fields);
-
- free(fields);
-
ret = LTTNG_OK;
break;
}
* Setup lttng message with payload size set to the event list size in
* bytes and then copy list into the llm payload.
*/
- ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_event) * nb_events);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, events,
+ sizeof(struct lttng_event) * nb_events);
+ free(events);
+
if (ret < 0) {
- free(events);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, events,
- sizeof(struct lttng_event) * nb_events);
-
- free(events);
-
ret = LTTNG_OK;
break;
}
* Setup lttng message with payload size set to the event list size in
* bytes and then copy list into the llm payload.
*/
- ret = setup_lttng_msg(cmd_ctx, sizeof(int32_t) * nr_pids);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, pids,
+ sizeof(int32_t) * nr_pids);
+ free(pids);
+
if (ret < 0) {
- free(pids);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, pids,
- sizeof(int) * nr_pids);
-
- free(pids);
-
ret = LTTNG_OK;
break;
}
goto error;
}
- ret = setup_lttng_msg(cmd_ctx, nb_dom * sizeof(struct lttng_domain));
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, domains,
+ nb_dom * sizeof(struct lttng_domain));
+ free(domains);
+
if (ret < 0) {
- free(domains);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, domains,
- nb_dom * sizeof(struct lttng_domain));
-
- free(domains);
-
ret = LTTNG_OK;
break;
}
case LTTNG_LIST_CHANNELS:
{
- int nb_chan;
+ ssize_t payload_size;
struct lttng_channel *channels = NULL;
- nb_chan = cmd_list_channels(cmd_ctx->lsm->domain.type,
+ payload_size = cmd_list_channels(cmd_ctx->lsm->domain.type,
cmd_ctx->session, &channels);
- if (nb_chan < 0) {
+ if (payload_size < 0) {
/* Return value is a negative lttng_error_code. */
- ret = -nb_chan;
+ ret = -payload_size;
goto error;
}
- ret = setup_lttng_msg(cmd_ctx, nb_chan * sizeof(struct lttng_channel));
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, channels,
+ payload_size);
+ free(channels);
+
if (ret < 0) {
- free(channels);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, channels,
- nb_chan * sizeof(struct lttng_channel));
-
- free(channels);
-
ret = LTTNG_OK;
break;
}
{
ssize_t nb_event;
struct lttng_event *events = NULL;
+ struct lttcomm_event_command_header cmd_header;
+ size_t total_size;
+
+ memset(&cmd_header, 0, sizeof(cmd_header));
+ /* Extended infos are included at the end of events */
+ nb_event = cmd_list_events(cmd_ctx->lsm->domain.type,
+ cmd_ctx->session, cmd_ctx->lsm->u.list.channel_name,
+ &events, &total_size);
- nb_event = cmd_list_events(cmd_ctx->lsm->domain.type, cmd_ctx->session,
- cmd_ctx->lsm->u.list.channel_name, &events);
if (nb_event < 0) {
/* Return value is a negative lttng_error_code. */
ret = -nb_event;
goto error;
}
- ret = setup_lttng_msg(cmd_ctx, nb_event * sizeof(struct lttng_event));
+ cmd_header.nb_events = nb_event;
+ ret = setup_lttng_msg(cmd_ctx, events, total_size,
+ &cmd_header, sizeof(cmd_header));
+ free(events);
+
if (ret < 0) {
- free(events);
goto setup_error;
}
- /* Copy event list into message payload */
- memcpy(cmd_ctx->llm->payload, events,
- nb_event * sizeof(struct lttng_event));
-
- free(events);
-
ret = LTTNG_OK;
break;
}
case LTTNG_LIST_SESSIONS:
{
unsigned int nr_sessions;
+ void *sessions_payload;
+ size_t payload_len;
session_lock_list();
nr_sessions = lttng_sessions_count(
LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
+ payload_len = sizeof(struct lttng_session) * nr_sessions;
+ sessions_payload = zmalloc(payload_len);
- ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * nr_sessions);
- if (ret < 0) {
+ if (!sessions_payload) {
session_unlock_list();
+ ret = -ENOMEM;
goto setup_error;
}
- /* Filled the session array */
- cmd_list_lttng_sessions((struct lttng_session *)(cmd_ctx->llm->payload),
+ cmd_list_lttng_sessions(sessions_payload,
LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
-
session_unlock_list();
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, sessions_payload,
+ payload_len);
+ free(sessions_payload);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
ret = LTTNG_OK;
break;
}
- case LTTNG_CALIBRATE:
- {
- ret = cmd_calibrate(cmd_ctx->lsm->domain.type,
- &cmd_ctx->lsm->u.calibrate);
- break;
- }
case LTTNG_REGISTER_CONSUMER:
{
struct consumer_data *cdata;
case LTTNG_DATA_PENDING:
{
int pending_ret;
-
- /* 1 byte to return whether or not data is pending */
- ret = setup_lttng_msg(cmd_ctx, 1);
- if (ret < 0) {
- goto setup_error;
- }
+ uint8_t pending_ret_byte;
pending_ret = cmd_data_pending(cmd_ctx->session);
+
/*
* FIXME
*
* "unknown" error.
*/
if (pending_ret == 0 || pending_ret == 1) {
- ret = LTTNG_OK;
+ /*
+ * ret will be set to LTTNG_OK at the end of
+ * this function.
+ */
} else if (pending_ret < 0) {
ret = LTTNG_ERR_UNK;
goto setup_error;
goto setup_error;
}
- *cmd_ctx->llm->payload = (uint8_t) pending_ret;
+ pending_ret_byte = (uint8_t) pending_ret;
+
+ /* 1 byte to return whether or not data is pending */
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx,
+ &pending_ret_byte, 1);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
break;
}
case LTTNG_SNAPSHOT_ADD_OUTPUT:
goto error;
}
- ret = setup_lttng_msg(cmd_ctx, sizeof(reply));
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply,
+ sizeof(reply));
if (ret < 0) {
goto setup_error;
}
/* Copy output list into message payload */
- memcpy(cmd_ctx->llm->payload, &reply, sizeof(reply));
ret = LTTNG_OK;
break;
}
goto error;
}
- ret = setup_lttng_msg(cmd_ctx,
+ assert((nb_output > 0 && outputs) || nb_output == 0);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, outputs,
nb_output * sizeof(struct lttng_snapshot_output));
+ free(outputs);
+
if (ret < 0) {
- free(outputs);
goto setup_error;
}
- if (outputs) {
- /* Copy output list into message payload */
- memcpy(cmd_ctx->llm->payload, outputs,
- nb_output * sizeof(struct lttng_snapshot_output));
- free(outputs);
- }
-
ret = LTTNG_OK;
break;
}
cmd_ctx->lsm->u.set_shm_path.shm_path);
break;
}
+ case LTTNG_REGENERATE_METADATA:
+ {
+ ret = cmd_regenerate_metadata(cmd_ctx->session);
+ break;
+ }
+ case LTTNG_REGENERATE_STATEDUMP:
+ {
+ ret = cmd_regenerate_statedump(cmd_ctx->session);
+ break;
+ }
+ case LTTNG_REGISTER_TRIGGER:
+ {
+ ret = cmd_register_trigger(cmd_ctx, sock,
+ notification_thread_handle);
+ break;
+ }
+ case LTTNG_UNREGISTER_TRIGGER:
+ {
+ ret = cmd_unregister_trigger(cmd_ctx, sock,
+ notification_thread_handle);
+ break;
+ }
default:
ret = LTTNG_ERR_UND;
break;
error:
if (cmd_ctx->llm == NULL) {
DBG("Missing llm structure. Allocating one.");
- if (setup_lttng_msg(cmd_ctx, 0) < 0) {
+ if (setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0) < 0) {
goto setup_error;
}
}
session_unlock_list();
}
init_setup_error:
+ assert(!rcu_read_ongoing());
return ret;
}
sock = lttcomm_create_unix_sock(health_unix_sock_path);
if (sock < 0) {
ERR("Unable to create health check Unix socket");
- ret = -1;
goto error;
}
if (ret < 0) {
ERR("Unable to set group on %s", health_unix_sock_path);
PERROR("chown");
- ret = -1;
goto error;
}
if (ret < 0) {
ERR("Unable to set permissions on %s", health_unix_sock_path);
PERROR("chmod");
- ret = -1;
goto error;
}
}
/* Event on the registration socket */
if (pollfd == sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ if (revents & LPOLLIN) {
+ continue;
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
ERR("Health socket poll error");
goto error;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
}
if (ret) {
PERROR("close");
}
- new_sock = -1;
continue;
}
if (ret) {
PERROR("close");
}
- new_sock = -1;
}
exit:
}
lttng_poll_clean(&events);
-
+ stop_threads();
rcu_unregister_thread();
return NULL;
}
/* Event on the registration socket */
if (pollfd == client_sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ if (revents & LPOLLIN) {
+ continue;
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
ERR("Client socket poll error");
goto error;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
}
}
}
return NULL;
}
-
-/*
- * usage function on stderr
- */
-static void usage(void)
-{
- fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname);
- fprintf(stderr, " -h, --help Display this usage.\n");
- fprintf(stderr, " -c, --client-sock PATH Specify path for the client unix socket\n");
- fprintf(stderr, " -a, --apps-sock PATH Specify path for apps unix socket\n");
- fprintf(stderr, " --kconsumerd-err-sock PATH Specify path for the kernel consumer error socket\n");
- fprintf(stderr, " --kconsumerd-cmd-sock PATH Specify path for the kernel consumer command socket\n");
- fprintf(stderr, " --ustconsumerd32-err-sock PATH Specify path for the 32-bit UST consumer error socket\n");
- fprintf(stderr, " --ustconsumerd64-err-sock PATH Specify path for the 64-bit UST consumer error socket\n");
- fprintf(stderr, " --ustconsumerd32-cmd-sock PATH Specify path for the 32-bit UST consumer command socket\n");
- fprintf(stderr, " --ustconsumerd64-cmd-sock PATH Specify path for the 64-bit UST consumer command socket\n");
- fprintf(stderr, " --consumerd32-path PATH Specify path for the 32-bit UST consumer daemon binary\n");
- fprintf(stderr, " --consumerd32-libdir PATH Specify path for the 32-bit UST consumer daemon libraries\n");
- fprintf(stderr, " --consumerd64-path PATH Specify path for the 64-bit UST consumer daemon binary\n");
- fprintf(stderr, " --consumerd64-libdir PATH Specify path for the 64-bit UST consumer daemon libraries\n");
- fprintf(stderr, " -d, --daemonize Start as a daemon.\n");
- fprintf(stderr, " -b, --background Start as a daemon, keeping console open.\n");
- fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
- fprintf(stderr, " -V, --version Show version number.\n");
- fprintf(stderr, " -S, --sig-parent Send SIGUSR1 to parent pid to notify readiness.\n");
- fprintf(stderr, " -q, --quiet No output at all.\n");
- fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
- fprintf(stderr, " -p, --pidfile FILE Write a pid to FILE name overriding the default value.\n");
- fprintf(stderr, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n");
- fprintf(stderr, " --no-kernel Disable kernel tracer\n");
- fprintf(stderr, " --agent-tcp-port Agent registration TCP port\n");
- fprintf(stderr, " -f --config PATH Load daemon configuration file\n");
- fprintf(stderr, " -l --load PATH Load session configuration\n");
- fprintf(stderr, " --kmod-probes Specify kernel module probes to load\n");
- fprintf(stderr, " --extra-kmod-probes Specify extra kernel module probes to load\n");
-}
-
static int string_match(const char *str1, const char *str2)
{
return (str1 && str2) && !strcmp(str1, str2);
{
int ret = 0;
- if (arg && arg[0] == '\0') {
- /*
- * This only happens if the value is read from daemon config
- * file. This means the option requires an argument and the
- * configuration file contains a line such as:
- * my_option =
- */
- ret = -EINVAL;
- goto end;
- }
-
if (string_match(optname, "client-sock") || opt == 'c') {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"-c, --client-sock");
snprintf(client_unix_sock_path, PATH_MAX, "%s", arg);
}
} else if (string_match(optname, "apps-sock") || opt == 'a') {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"-a, --apps-sock");
} else if (string_match(optname, "background") || opt == 'b') {
opt_background = 1;
} else if (string_match(optname, "group") || opt == 'g') {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"-g, --group");
tracing_group_name_override = 1;
}
} else if (string_match(optname, "help") || opt == 'h') {
- usage();
- exit(EXIT_SUCCESS);
+ ret = utils_show_help(8, "lttng-sessiond", help_msg);
+ if (ret) {
+ ERR("Cannot show --help for `lttng-sessiond`");
+ perror("exec");
+ }
+ exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
} else if (string_match(optname, "version") || opt == 'V') {
fprintf(stdout, "%s\n", VERSION);
exit(EXIT_SUCCESS);
} else if (string_match(optname, "sig-parent") || opt == 'S') {
opt_sig_parent = 1;
} else if (string_match(optname, "kconsumerd-err-sock")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--kconsumerd-err-sock");
snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX, "%s", arg);
}
} else if (string_match(optname, "kconsumerd-cmd-sock")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--kconsumerd-cmd-sock");
snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
}
} else if (string_match(optname, "ustconsumerd64-err-sock")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--ustconsumerd64-err-sock");
snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX, "%s", arg);
}
} else if (string_match(optname, "ustconsumerd64-cmd-sock")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--ustconsumerd64-cmd-sock");
snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
}
} else if (string_match(optname, "ustconsumerd32-err-sock")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--ustconsumerd32-err-sock");
snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX, "%s", arg);
}
} else if (string_match(optname, "ustconsumerd32-cmd-sock")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--ustconsumerd32-cmd-sock");
if (arg) {
opt_verbose_consumer = config_parse_value(arg);
} else {
- opt_verbose_consumer += 1;
+ opt_verbose_consumer++;
}
} else if (string_match(optname, "consumerd32-path")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--consumerd32-path");
consumerd32_bin_override = 1;
}
} else if (string_match(optname, "consumerd32-libdir")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--consumerd32-libdir");
consumerd32_libdir_override = 1;
}
} else if (string_match(optname, "consumerd64-path")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--consumerd64-path");
consumerd64_bin_override = 1;
}
} else if (string_match(optname, "consumerd64-libdir")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--consumerd64-libdir");
consumerd64_libdir_override = 1;
}
} else if (string_match(optname, "pidfile") || opt == 'p') {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"-p, --pidfile");
}
}
} else if (string_match(optname, "agent-tcp-port")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--agent-tcp-port");
} else {
unsigned long v;
- if (!arg) {
- ret = -EINVAL;
- goto end;
- }
errno = 0;
v = strtoul(arg, NULL, 0);
if (errno != 0 || !isdigit(arg[0])) {
DBG3("Agent TCP port set to non default: %u", agent_tcp_port);
}
} else if (string_match(optname, "load") || opt == 'l') {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"-l, --load");
}
}
} else if (string_match(optname, "kmod-probes")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--kmod-probes");
}
}
} else if (string_match(optname, "extra-kmod-probes")) {
+ if (!arg || *arg == '\0') {
+ ret = -EINVAL;
+ goto end;
+ }
if (lttng_is_setuid_setgid()) {
WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
"--extra-kmod-probes");
/*
* config_entry_handler_cb used to handle options read from a config file.
- * See config_entry_handler_cb comment in common/config/config.h for the
+ * See config_entry_handler_cb comment in common/config/session-config.h for the
* return value conventions.
*/
static int config_entry_handler(const struct config_entry *entry, void *unused)
static void sighandler(int sig)
{
switch (sig) {
- case SIGPIPE:
- DBG("SIGPIPE caught");
- return;
case SIGINT:
DBG("SIGINT caught");
stop_threads();
return ret;
}
- sa.sa_handler = sighandler;
sa.sa_mask = sigset;
sa.sa_flags = 0;
+
+ sa.sa_handler = sighandler;
if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
PERROR("sigaction");
return ret;
return ret;
}
- if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
+ if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
PERROR("sigaction");
return ret;
}
- if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
+ sa.sa_handler = SIG_IGN;
+ if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
PERROR("sigaction");
return ret;
}
/*
* Set open files limit to unlimited. This daemon can open a large number of
- * file descriptors in order to consumer multiple kernel traces.
+ * file descriptors in order to consume multiple kernel traces.
*/
static void set_ulimit(void)
{
int ret;
struct rlimit lim;
- /* The kernel does not allowed an infinite limit for open files */
+ /* The kernel does not allow an infinite limit for open files */
lim.rlim_cur = 65535;
lim.rlim_max = 65535;
assert(rundir);
if (opt_pidfile) {
- strncpy(pidfile_path, opt_pidfile, sizeof(pidfile_path));
+ if (lttng_strncpy(pidfile_path, opt_pidfile, sizeof(pidfile_path))) {
+ ret = -1;
+ goto error;
+ }
} else {
/* Build pidfile path from rundir and opt_pidfile. */
ret = snprintf(pidfile_path, sizeof(pidfile_path), "%s/"
int ret = 0, retval = 0;
void *status;
const char *home_path, *env_app_timeout;
+ struct lttng_pipe *ust32_channel_monitor_pipe = NULL,
+ *ust64_channel_monitor_pipe = NULL,
+ *kernel_channel_monitor_pipe = NULL;
+ bool notification_thread_running = false;
init_kernel_workarounds();
}
}
+ if (run_as_create_worker(argv[0]) < 0) {
+ goto exit_create_run_as_worker_cleanup;
+ }
+
/*
* Starting from here, we can create threads. This needs to be after
* lttng_daemonize due to RCU.
goto exit_health_sessiond_cleanup;
}
- if (init_ht_cleanup_quit_pipe()) {
- retval = -1;
- goto exit_ht_cleanup_quit_pipe;
- }
-
- /* Setup the thread ht_cleanup communication pipe. */
- if (utils_create_pipe_cloexec(ht_cleanup_pipe)) {
- retval = -1;
- goto exit_ht_cleanup_pipe;
- }
-
- /* Set up max poll set size */
- if (lttng_poll_set_max_size()) {
- retval = -1;
- goto exit_set_max_size;
- }
-
/* Create thread to clean up RCU hash tables */
- ret = pthread_create(&ht_cleanup_thread, NULL,
- thread_ht_cleanup, (void *) NULL);
- if (ret) {
- errno = ret;
- PERROR("pthread_create ht_cleanup");
+ if (init_ht_cleanup_thread(&ht_cleanup_thread)) {
retval = -1;
goto exit_ht_cleanup;
}
kconsumer_data.err_unix_sock_path);
DBG2("Kernel consumer cmd path: %s",
kconsumer_data.cmd_unix_sock_path);
+ kernel_channel_monitor_pipe = lttng_pipe_open(0);
+ if (!kernel_channel_monitor_pipe) {
+ ERR("Failed to create kernel consumer channel monitor pipe");
+ retval = -1;
+ goto exit_init_data;
+ }
+ kconsumer_data.channel_monitor_pipe =
+ lttng_pipe_release_writefd(
+ kernel_channel_monitor_pipe);
+ if (kconsumer_data.channel_monitor_pipe < 0) {
+ retval = -1;
+ goto exit_init_data;
+ }
} else {
home_path = utils_get_home_dir();
if (home_path == NULL) {
ustconsumer32_data.err_unix_sock_path);
DBG2("UST consumer 32 bits cmd path: %s",
ustconsumer32_data.cmd_unix_sock_path);
+ ust32_channel_monitor_pipe = lttng_pipe_open(0);
+ if (!ust32_channel_monitor_pipe) {
+ ERR("Failed to create 32-bit user space consumer channel monitor pipe");
+ retval = -1;
+ goto exit_init_data;
+ }
+ ustconsumer32_data.channel_monitor_pipe = lttng_pipe_release_writefd(
+ ust32_channel_monitor_pipe);
+ if (ustconsumer32_data.channel_monitor_pipe < 0) {
+ retval = -1;
+ goto exit_init_data;
+ }
/* 64 bits consumerd path setup */
ret = snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX,
ustconsumer64_data.err_unix_sock_path);
DBG2("UST consumer 64 bits cmd path: %s",
ustconsumer64_data.cmd_unix_sock_path);
+ ust64_channel_monitor_pipe = lttng_pipe_open(0);
+ if (!ust64_channel_monitor_pipe) {
+ ERR("Failed to create 64-bit user space consumer channel monitor pipe");
+ retval = -1;
+ goto exit_init_data;
+ }
+ ustconsumer64_data.channel_monitor_pipe = lttng_pipe_release_writefd(
+ ust64_channel_monitor_pipe);
+ if (ustconsumer64_data.channel_monitor_pipe < 0) {
+ retval = -1;
+ goto exit_init_data;
+ }
/*
* See if daemon already exist.
}
load_info->path = opt_load_session_path;
- /* Create health-check thread */
- ret = pthread_create(&health_thread, NULL,
+ /* Create health-check thread. */
+ ret = pthread_create(&health_thread, default_pthread_attr(),
thread_manage_health, (void *) NULL);
if (ret) {
errno = ret;
goto exit_health;
}
+ /* notification_thread_data acquires the pipes' read side. */
+ notification_thread_handle = notification_thread_handle_create(
+ ust32_channel_monitor_pipe,
+ ust64_channel_monitor_pipe,
+ kernel_channel_monitor_pipe);
+ if (!notification_thread_handle) {
+ retval = -1;
+ ERR("Failed to create notification thread shared data");
+ stop_threads();
+ goto exit_notification;
+ }
+
+ /* Create notification thread. */
+ ret = pthread_create(¬ification_thread, default_pthread_attr(),
+ thread_notification, notification_thread_handle);
+ if (ret) {
+ errno = ret;
+ PERROR("pthread_create notification");
+ retval = -1;
+ stop_threads();
+ goto exit_notification;
+ }
+ notification_thread_running = true;
+
/* Create thread to manage the client socket */
- ret = pthread_create(&client_thread, NULL,
+ ret = pthread_create(&client_thread, default_pthread_attr(),
thread_manage_clients, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create clients");
retval = -1;
+ stop_threads();
goto exit_client;
}
/* Create thread to dispatch registration */
- ret = pthread_create(&dispatch_thread, NULL,
+ ret = pthread_create(&dispatch_thread, default_pthread_attr(),
thread_dispatch_ust_registration, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create dispatch");
retval = -1;
+ stop_threads();
goto exit_dispatch;
}
/* Create thread to manage application registration. */
- ret = pthread_create(®_apps_thread, NULL,
+ ret = pthread_create(®_apps_thread, default_pthread_attr(),
thread_registration_apps, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create registration");
retval = -1;
+ stop_threads();
goto exit_reg_apps;
}
/* Create thread to manage application socket */
- ret = pthread_create(&apps_thread, NULL,
+ ret = pthread_create(&apps_thread, default_pthread_attr(),
thread_manage_apps, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create apps");
retval = -1;
+ stop_threads();
goto exit_apps;
}
/* Create thread to manage application notify socket */
- ret = pthread_create(&apps_notify_thread, NULL,
+ ret = pthread_create(&apps_notify_thread, default_pthread_attr(),
ust_thread_manage_notify, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create notify");
retval = -1;
+ stop_threads();
goto exit_apps_notify;
}
/* Create agent registration thread. */
- ret = pthread_create(&agent_reg_thread, NULL,
+ ret = pthread_create(&agent_reg_thread, default_pthread_attr(),
agent_thread_manage_registration, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create agent");
retval = -1;
+ stop_threads();
goto exit_agent_reg;
}
/* Don't start this thread if kernel tracing is not requested nor root */
if (is_root && !opt_no_kernel) {
/* Create kernel thread to manage kernel event */
- ret = pthread_create(&kernel_thread, NULL,
+ ret = pthread_create(&kernel_thread, default_pthread_attr(),
thread_manage_kernel, (void *) NULL);
if (ret) {
errno = ret;
PERROR("pthread_create kernel");
retval = -1;
+ stop_threads();
goto exit_kernel;
}
}
/* Create session loading thread. */
- ret = pthread_create(&load_session_thread, NULL, thread_load_session,
- load_info);
+ ret = pthread_create(&load_session_thread, default_pthread_attr(),
+ thread_load_session, load_info);
if (ret) {
errno = ret;
PERROR("pthread_create load_session_thread");
retval = -1;
+ stop_threads();
goto exit_load_session;
}
}
exit_reg_apps:
+ /*
+ * Join dispatch thread after joining reg_apps_thread to ensure
+ * we don't leak applications in the queue.
+ */
ret = pthread_join(dispatch_thread, &status);
if (ret) {
errno = ret;
PERROR("pthread_join");
retval = -1;
}
-exit_client:
+exit_client:
+exit_notification:
ret = pthread_join(health_thread, &status);
if (ret) {
errno = ret;
PERROR("pthread_join health thread");
retval = -1;
}
-exit_health:
+exit_health:
exit_init_data:
+ /*
+ * Wait for all pending call_rcu work to complete before tearing
+ * down data structures. call_rcu worker may be trying to
+ * perform lookups in those structures.
+ */
+ rcu_barrier();
/*
* sessiond_cleanup() is called when no other thread is running, except
* the ht_cleanup thread, which is needed to destroy the hash tables.
*/
rcu_thread_online();
sessiond_cleanup();
- rcu_thread_offline();
- rcu_unregister_thread();
- ret = notify_thread_pipe(ht_cleanup_quit_pipe[1]);
- if (ret < 0) {
- ERR("write error on ht_cleanup quit pipe");
- retval = -1;
+ /*
+ * Ensure all prior call_rcu are done. call_rcu callbacks may push
+ * hash tables to the ht_cleanup thread. Therefore, we ensure that
+ * the queue is empty before shutting down the clean-up thread.
+ */
+ rcu_barrier();
+
+ /*
+ * The teardown of the notification system is performed after the
+ * session daemon's teardown in order to allow it to be notified
+ * of the active session and channels at the moment of the teardown.
+ */
+ if (notification_thread_handle) {
+ if (notification_thread_running) {
+ notification_thread_command_quit(
+ notification_thread_handle);
+ ret = pthread_join(notification_thread, &status);
+ if (ret) {
+ errno = ret;
+ PERROR("pthread_join notification thread");
+ retval = -1;
+ }
+ }
+ notification_thread_handle_destroy(notification_thread_handle);
}
- ret = pthread_join(ht_cleanup_thread, &status);
+ rcu_thread_offline();
+ rcu_unregister_thread();
+
+ ret = fini_ht_cleanup_thread(&ht_cleanup_thread);
if (ret) {
- errno = ret;
- PERROR("pthread_join ht cleanup thread");
retval = -1;
}
+ lttng_pipe_destroy(ust32_channel_monitor_pipe);
+ lttng_pipe_destroy(ust64_channel_monitor_pipe);
+ lttng_pipe_destroy(kernel_channel_monitor_pipe);
exit_ht_cleanup:
-exit_set_max_size:
-
- utils_close_pipe(ht_cleanup_pipe);
-exit_ht_cleanup_pipe:
-
- /*
- * Close the ht_cleanup quit pipe.
- */
- utils_close_pipe(ht_cleanup_quit_pipe);
-exit_ht_cleanup_quit_pipe:
health_app_destroy(health_sessiond);
exit_health_sessiond_cleanup:
+exit_create_run_as_worker_cleanup:
exit_options:
sessiond_cleanup_options();
projects / lttng-tools.git / blobdiff