#include <common/config/session-config.h>
#include <common/dynamic-buffer.h>
#include <lttng/userspace-probe-internal.h>
+#include <lttng/event-internal.h>
#include "lttng-sessiond.h"
#include "buffer-registry.h"
#include "agent.h"
#include "ht-cleanup.h"
#include "sessiond-config.h"
-#include "sessiond-timer.h"
+#include "timer.h"
static const char *help_msg =
#ifdef LTTNG_EMBED_HELP
.err_sock = -1,
.cmd_sock = -1,
.channel_monitor_pipe = -1,
- .channel_rotate_pipe = -1,
.pid_mutex = PTHREAD_MUTEX_INITIALIZER,
.lock = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
.err_sock = -1,
.cmd_sock = -1,
.channel_monitor_pipe = -1,
- .channel_rotate_pipe = -1,
.pid_mutex = PTHREAD_MUTEX_INITIALIZER,
.lock = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
.err_sock = -1,
.cmd_sock = -1,
.channel_monitor_pipe = -1,
- .channel_rotate_pipe = -1,
.pid_mutex = PTHREAD_MUTEX_INITIALIZER,
.lock = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER,
PERROR("UST consumerd64 channel monitor pipe close");
}
}
- if (kconsumer_data.channel_rotate_pipe >= 0) {
- ret = close(kconsumer_data.channel_rotate_pipe);
- if (ret < 0) {
- PERROR("kernel consumer channel rotate pipe close");
- }
- }
- if (ustconsumer32_data.channel_rotate_pipe >= 0) {
- ret = close(ustconsumer32_data.channel_rotate_pipe);
- if (ret < 0) {
- PERROR("UST consumerd32 channel rotate pipe close");
- }
- }
- if (ustconsumer64_data.channel_rotate_pipe >= 0) {
- ret = close(ustconsumer64_data.channel_rotate_pipe);
- if (ret < 0) {
- PERROR("UST consumerd64 channel rotate pipe close");
- }
- }
}
/*
/*
* Transfer the write-end of the channel monitoring and rotate pipe
- * to the consumer by issuing a SET_CHANNEL_MONITOR_PIPE and
- * SET_CHANNEL_ROTATE_PIPE commands.
+ * to the consumer 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_rotate_pipe(cmd_socket_wrapper,
- consumer_data->channel_rotate_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;
} else if (stat(INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE, &st) == 0) {
DBG3("Found location #2");
consumer_to_use = INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE;
- } else if (stat(config.consumerd32_bin_path.value, &st) == 0) {
+ } else if (config.consumerd32_bin_path.value &&
+ stat(config.consumerd32_bin_path.value, &st) == 0) {
DBG3("Found location #3");
consumer_to_use = config.consumerd32_bin_path.value;
} else {
{
int fd, ret;
struct lttng_userspace_probe_location *probe_location;
- struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
+ const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
struct lttng_dynamic_buffer probe_location_buffer;
struct lttng_buffer_view buffer_view;
case LTTNG_UNREGISTER_TRIGGER:
case LTTNG_ROTATE_SESSION:
case LTTNG_ROTATION_GET_INFO:
- case LTTNG_SESSION_GET_CURRENT_OUTPUT:
case LTTNG_ROTATION_SET_SCHEDULE:
case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
need_domain = 0;
}
/*
- * Setup socket for consumer 64 bit. No need for atomic access
+ * Setup socket for consumer 32 bit. No need for atomic access
* since it was set above and can ONLY be set in this thread.
*/
ret = consumer_create_socket(&ustconsumer32_data,
if (!ev) {
DBG("Failed to copy event: %s",
cmd_ctx->lsm->u.enable.event.name);
+ free(filter_expression);
+ free(bytecode);
+ free(exclusion);
ret = LTTNG_ERR_NOMEM;
goto error;
}
/* Expect a userspace probe description. */
ret = receive_userspace_probe(cmd_ctx, sock, sock_error, ev);
if (ret) {
+ free(filter_expression);
+ free(bytecode);
+ free(exclusion);
lttng_event_destroy(ev);
goto error;
}
ret = LTTNG_OK;
break;
}
- case LTTNG_SESSION_GET_CURRENT_OUTPUT:
- {
- struct lttng_session_get_current_output_return output_return;
-
- memset(&output_return, 0, sizeof(output_return));
- ret = cmd_session_get_current_output(cmd_ctx->session,
- &output_return);
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &output_return,
- sizeof(output_return));
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = LTTNG_OK;
- break;
- }
case LTTNG_ROTATION_SET_SCHEDULE:
{
bool set_schedule;
return ret;
}
-static
-struct rotation_thread_timer_queue *create_rotate_timer_queue(void)
-{
- struct rotation_thread_timer_queue *queue = NULL;
-
- queue = zmalloc(sizeof(struct rotation_thread_timer_queue));
- if (!queue) {
- PERROR("Failed to allocate timer rotate queue");
- goto end;
- }
-
- queue->event_pipe = lttng_pipe_open(FD_CLOEXEC | O_NONBLOCK);
- CDS_INIT_LIST_HEAD(&queue->list);
- pthread_mutex_init(&queue->lock, NULL);
-
-end:
- return queue;
-}
-
-static
-void destroy_rotate_timer_queue(struct rotation_thread_timer_queue *queue)
-{
- struct sessiond_rotation_timer *node, *tmp_node;
-
- if (!queue) {
- return;
- }
-
- lttng_pipe_destroy(queue->event_pipe);
-
- pthread_mutex_lock(&queue->lock);
- /* Empty wait queue. */
- cds_list_for_each_entry_safe(node, tmp_node, &queue->list, head) {
- cds_list_del(&node->head);
- free(node);
- }
- pthread_mutex_unlock(&queue->lock);
-
- pthread_mutex_destroy(&queue->lock);
- free(queue);
-}
-
/*
* main
*/
bool notification_thread_launched = false;
bool rotation_thread_launched = false;
bool timer_thread_launched = false;
- struct lttng_pipe *ust32_channel_rotate_pipe = NULL,
- *ust64_channel_rotate_pipe = NULL,
- *kernel_channel_rotate_pipe = NULL;
struct timer_thread_parameters timer_thread_ctx;
/* Queue of rotation jobs populated by the sessiond-timer. */
struct rotation_thread_timer_queue *rotation_timer_queue = NULL;
goto exit_set_signal_handler;
}
- if (sessiond_timer_signal_init()) {
+ if (timer_signal_init()) {
retval = -1;
goto exit_set_signal_handler;
}
retval = -1;
goto exit_init_data;
}
- kernel_channel_rotate_pipe = lttng_pipe_open(0);
- if (!kernel_channel_rotate_pipe) {
- ERR("Failed to create kernel consumer channel rotate pipe");
- retval = -1;
- goto exit_init_data;
- }
- kconsumer_data.channel_rotate_pipe =
- lttng_pipe_release_writefd(
- kernel_channel_rotate_pipe);
- if (kconsumer_data.channel_rotate_pipe < 0) {
- retval = -1;
- goto exit_init_data;
- }
}
/* Set consumer initial state */
retval = -1;
goto exit_init_data;
}
- ust32_channel_rotate_pipe = lttng_pipe_open(0);
- if (!ust32_channel_rotate_pipe) {
- ERR("Failed to create 32-bit user space consumer channel rotate pipe");
- retval = -1;
- goto exit_init_data;
- }
- ustconsumer32_data.channel_rotate_pipe = lttng_pipe_release_writefd(
- ust32_channel_rotate_pipe);
- if (ustconsumer32_data.channel_rotate_pipe < 0) {
- retval = -1;
- goto exit_init_data;
- }
/*
- * The rotation_timer_queue structure is shared between the sessiond timer
- * thread and the rotation thread. The main() keeps the ownership and
- * destroys it when both threads have quit.
+ * The rotation_thread_timer_queue structure is shared between the
+ * sessiond timer thread and the rotation thread. The main thread keeps
+ * its ownership and destroys it when both threads have been joined.
*/
- rotation_timer_queue = create_rotate_timer_queue();
+ rotation_timer_queue = rotation_thread_timer_queue_create();
if (!rotation_timer_queue) {
retval = -1;
goto exit_init_data;
}
- timer_thread_ctx.rotation_timer_queue = rotation_timer_queue;
+ timer_thread_ctx.rotation_thread_job_queue = rotation_timer_queue;
ust64_channel_monitor_pipe = lttng_pipe_open(0);
if (!ust64_channel_monitor_pipe) {
retval = -1;
goto exit_init_data;
}
- ust64_channel_rotate_pipe = lttng_pipe_open(0);
- if (!ust64_channel_rotate_pipe) {
- ERR("Failed to create 64-bit user space consumer channel rotate pipe");
- retval = -1;
- goto exit_init_data;
- }
- ustconsumer64_data.channel_rotate_pipe = lttng_pipe_release_writefd(
- ust64_channel_rotate_pipe);
- if (ustconsumer64_data.channel_rotate_pipe < 0) {
- retval = -1;
- goto exit_init_data;
- }
/*
* Init UST app hash table. Alloc hash table before this point since
/* Create timer thread. */
ret = pthread_create(&timer_thread, default_pthread_attr(),
- sessiond_timer_thread, &timer_thread_ctx);
+ timer_thread_func, &timer_thread_ctx);
if (ret) {
errno = ret;
PERROR("pthread_create timer");
/* rotation_thread_data acquires the pipes' read side. */
rotation_thread_handle = rotation_thread_handle_create(
- ust32_channel_rotate_pipe,
- ust64_channel_rotate_pipe,
- kernel_channel_rotate_pipe,
thread_quit_pipe[0],
rotation_timer_queue,
notification_thread_handle,
}
if (timer_thread_launched) {
- kill(getpid(), LTTNG_SESSIOND_SIG_EXIT);
+ timer_exit();
ret = pthread_join(timer_thread, &status);
if (ret) {
errno = ret;
* After the rotation and timer thread have quit, we can safely destroy
* the rotation_timer_queue.
*/
- destroy_rotate_timer_queue(rotation_timer_queue);
+ rotation_thread_timer_queue_destroy(rotation_timer_queue);
rcu_thread_offline();
rcu_unregister_thread();
lttng_pipe_destroy(ust32_channel_monitor_pipe);
lttng_pipe_destroy(ust64_channel_monitor_pipe);
lttng_pipe_destroy(kernel_channel_monitor_pipe);
- lttng_pipe_destroy(ust32_channel_rotate_pipe);
- lttng_pipe_destroy(ust64_channel_rotate_pipe);
- lttng_pipe_destroy(kernel_channel_rotate_pipe);
exit_ht_cleanup:
health_app_destroy(health_sessiond);
projects / lttng-tools.git / blobdiff