X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=020a8756a29d751960846512e32bb49ee4b53862;hp=bbc122152204bf4308a15f9afbe6a58dd4b587b3;hb=124473a3e6a82e10bbb23727fdff6e1f0c0415cb;hpb=18a720cd7bbc2eeea6d075903668e21337b5d916 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index bbc122152..507274f35 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -1,5 +1,6 @@ /* * Copyright (C) 2012 - David Goulet + * Copyright (C) 2016 - Jérémie Galarneau * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License, version 2 only, as @@ -15,17 +16,31 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include #include +#include #include #include #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "channel.h" #include "consumer.h" @@ -35,9 +50,42 @@ #include "kernel-consumer.h" #include "lttng-sessiond.h" #include "utils.h" +#include "lttng-syscall.h" +#include "agent.h" +#include "buffer-registry.h" +#include "notification-thread.h" +#include "notification-thread-commands.h" +#include "rotate.h" +#include "rotation-thread.h" +#include "timer.h" +#include "agent-thread.h" #include "cmd.h" +/* Sleep for 100ms between each check for the shm path's deletion. */ +#define SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US 100000 + +static enum lttng_error_code wait_on_path(void *path); + +/* + * Command completion handler that is used by the destroy command + * when a session that has a non-default shm_path is being destroyed. + * + * See comment in cmd_destroy_session() for the rationale. + */ +static struct destroy_completion_handler { + struct cmd_completion_handler handler; + char shm_path[member_sizeof(struct ltt_session, shm_path)]; +} destroy_completion_handler = { + .handler = { + .run = wait_on_path, + .data = destroy_completion_handler.shm_path + }, + .shm_path = { 0 }, +}; + +static struct cmd_completion_handler *current_completion_handler; + /* * Used to keep a unique index for each relayd socket created where this value * is associated with streams on the consumer so it can match the right relayd @@ -47,20 +95,14 @@ static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER; static uint64_t relayd_net_seq_idx; -/* - * Both functions below are special case for the Kernel domain when - * enabling/disabling all events. - */ -static -int enable_kevent_all(struct ltt_session *session, - struct lttng_domain *domain, char *channel_name, - struct lttng_event *event, +static int validate_ust_event_name(const char *); +static int cmd_enable_event_internal(struct ltt_session *session, + struct lttng_domain *domain, + char *channel_name, struct lttng_event *event, char *filter_expression, - struct lttng_filter_bytecode *filter, int wpipe); -static -int disable_kevent_all(struct ltt_session *session, int domain, - char *channel_name, - struct lttng_event *event); + struct lttng_filter_bytecode *filter, + struct lttng_event_exclusion *exclusion, + int wpipe); /* * Create a session path used by list_lttng_sessions for the case that the @@ -140,13 +182,105 @@ error: return ret; } +/* + * Get run-time attributes if the session has been started (discarded events, + * lost packets). + */ +static int get_kernel_runtime_stats(struct ltt_session *session, + struct ltt_kernel_channel *kchan, uint64_t *discarded_events, + uint64_t *lost_packets) +{ + int ret; + + if (!session->has_been_started) { + ret = 0; + *discarded_events = 0; + *lost_packets = 0; + goto end; + } + + ret = consumer_get_discarded_events(session->id, kchan->key, + session->kernel_session->consumer, + discarded_events); + if (ret < 0) { + goto end; + } + + ret = consumer_get_lost_packets(session->id, kchan->key, + session->kernel_session->consumer, + lost_packets); + if (ret < 0) { + goto end; + } + +end: + return ret; +} + +/* + * Get run-time attributes if the session has been started (discarded events, + * lost packets). + */ +static int get_ust_runtime_stats(struct ltt_session *session, + struct ltt_ust_channel *uchan, uint64_t *discarded_events, + uint64_t *lost_packets) +{ + int ret; + struct ltt_ust_session *usess; + + if (!discarded_events || !lost_packets) { + ret = -1; + goto end; + } + + usess = session->ust_session; + assert(discarded_events); + assert(lost_packets); + + if (!usess || !session->has_been_started) { + *discarded_events = 0; + *lost_packets = 0; + ret = 0; + goto end; + } + + if (usess->buffer_type == LTTNG_BUFFER_PER_UID) { + ret = ust_app_uid_get_channel_runtime_stats(usess->id, + &usess->buffer_reg_uid_list, + usess->consumer, uchan->id, + uchan->attr.overwrite, + discarded_events, + lost_packets); + } else if (usess->buffer_type == LTTNG_BUFFER_PER_PID) { + ret = ust_app_pid_get_channel_runtime_stats(usess, + uchan, usess->consumer, + uchan->attr.overwrite, + discarded_events, + lost_packets); + if (ret < 0) { + goto end; + } + *discarded_events += uchan->per_pid_closed_app_discarded; + *lost_packets += uchan->per_pid_closed_app_lost; + } else { + ERR("Unsupported buffer type"); + assert(0); + ret = -1; + goto end; + } + +end: + return ret; +} + /* * Fill lttng_channel array of all channels. */ -static void list_lttng_channels(int domain, struct ltt_session *session, - struct lttng_channel *channels) +static ssize_t list_lttng_channels(enum lttng_domain_type domain, + struct ltt_session *session, struct lttng_channel *channels, + struct lttng_channel_extended *chan_exts) { - int i = 0; + int i = 0, ret = 0; struct ltt_kernel_channel *kchan; DBG("Listing channels for session %s", session->name); @@ -157,9 +291,26 @@ static void list_lttng_channels(int domain, struct ltt_session *session, if (session->kernel_session != NULL) { cds_list_for_each_entry(kchan, &session->kernel_session->channel_list.head, list) { + uint64_t discarded_events, lost_packets; + struct lttng_channel_extended *extended; + + extended = (struct lttng_channel_extended *) + kchan->channel->attr.extended.ptr; + + ret = get_kernel_runtime_stats(session, kchan, + &discarded_events, &lost_packets); + if (ret < 0) { + goto end; + } /* Copy lttng_channel struct to array */ memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel)); channels[i].enabled = kchan->enabled; + chan_exts[i].discarded_events = + discarded_events; + chan_exts[i].lost_packets = lost_packets; + chan_exts[i].monitor_timer_interval = + extended->monitor_timer_interval; + chan_exts[i].blocking_timeout = 0; i++; } } @@ -172,7 +323,12 @@ static void list_lttng_channels(int domain, struct ltt_session *session, rcu_read_lock(); cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht, &iter.iter, uchan, node.node) { - strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN); + uint64_t discarded_events = 0, lost_packets = 0; + + if (lttng_strncpy(channels[i].name, uchan->name, + LTTNG_SYMBOL_NAME_LEN)) { + break; + } channels[i].attr.overwrite = uchan->attr.overwrite; channels[i].attr.subbuf_size = uchan->attr.subbuf_size; channels[i].attr.num_subbuf = uchan->attr.num_subbuf; @@ -183,12 +339,35 @@ static void list_lttng_channels(int domain, struct ltt_session *session, channels[i].enabled = uchan->enabled; channels[i].attr.tracefile_size = uchan->tracefile_size; channels[i].attr.tracefile_count = uchan->tracefile_count; + + /* + * Map enum lttng_ust_output to enum lttng_event_output. + */ switch (uchan->attr.output) { case LTTNG_UST_MMAP: - default: channels[i].attr.output = LTTNG_EVENT_MMAP; break; + default: + /* + * LTTNG_UST_MMAP is the only supported UST + * output mode. + */ + assert(0); + break; + } + + chan_exts[i].monitor_timer_interval = + uchan->monitor_timer_interval; + chan_exts[i].blocking_timeout = + uchan->attr.u.s.blocking_timeout; + + ret = get_ust_runtime_stats(session, uchan, + &discarded_events, &lost_packets); + if (ret < 0) { + break; } + chan_exts[i].discarded_events = discarded_events; + chan_exts[i].lost_packets = lost_packets; i++; } rcu_read_unlock(); @@ -197,6 +376,107 @@ static void list_lttng_channels(int domain, struct ltt_session *session, default: break; } + +end: + if (ret < 0) { + return -LTTNG_ERR_FATAL; + } else { + return LTTNG_OK; + } +} + +static int increment_extended_len(const char *filter_expression, + struct lttng_event_exclusion *exclusion, + const struct lttng_userspace_probe_location *probe_location, + size_t *extended_len) +{ + int ret = 0; + + *extended_len += sizeof(struct lttcomm_event_extended_header); + + if (filter_expression) { + *extended_len += strlen(filter_expression) + 1; + } + + if (exclusion) { + *extended_len += exclusion->count * LTTNG_SYMBOL_NAME_LEN; + } + + if (probe_location) { + ret = lttng_userspace_probe_location_serialize(probe_location, + NULL, NULL); + if (ret < 0) { + goto end; + } + *extended_len += ret; + } + ret = 0; +end: + return ret; +} + +static int append_extended_info(const char *filter_expression, + struct lttng_event_exclusion *exclusion, + struct lttng_userspace_probe_location *probe_location, + void **extended_at) +{ + int ret = 0; + size_t filter_len = 0; + size_t nb_exclusions = 0; + size_t userspace_probe_location_len = 0; + struct lttng_dynamic_buffer location_buffer; + struct lttcomm_event_extended_header extended_header; + + if (filter_expression) { + filter_len = strlen(filter_expression) + 1; + } + + if (exclusion) { + nb_exclusions = exclusion->count; + } + + if (probe_location) { + lttng_dynamic_buffer_init(&location_buffer); + ret = lttng_userspace_probe_location_serialize(probe_location, + &location_buffer, NULL); + if (ret < 0) { + ret = -1; + goto end; + } + userspace_probe_location_len = location_buffer.size; + } + + /* Set header fields */ + extended_header.filter_len = filter_len; + extended_header.nb_exclusions = nb_exclusions; + extended_header.userspace_probe_location_len = userspace_probe_location_len; + + /* Copy header */ + memcpy(*extended_at, &extended_header, sizeof(extended_header)); + *extended_at += sizeof(extended_header); + + /* Copy filter string */ + if (filter_expression) { + memcpy(*extended_at, filter_expression, filter_len); + *extended_at += filter_len; + } + + /* Copy exclusion names */ + if (exclusion) { + size_t len = nb_exclusions * LTTNG_SYMBOL_NAME_LEN; + + memcpy(*extended_at, &exclusion->names, len); + *extended_at += len; + } + + if (probe_location) { + memcpy(*extended_at, location_buffer.data, location_buffer.size); + *extended_at += location_buffer.size; + lttng_dynamic_buffer_reset(&location_buffer); + } + ret = 0; +end: + return ret; } /* @@ -205,56 +485,97 @@ static void list_lttng_channels(int domain, struct ltt_session *session, * Return number of events in list on success or else a negative value. */ static int list_lttng_agent_events(struct agent *agt, - struct lttng_event **events) + struct lttng_event **events, size_t *total_size) { int i = 0, ret = 0; unsigned int nb_event = 0; struct agent_event *event; - struct lttng_event *tmp_events; + struct lttng_event *tmp_events = NULL; struct lttng_ht_iter iter; + size_t extended_len = 0; + void *extended_at; assert(agt); assert(events); DBG3("Listing agent events"); + rcu_read_lock(); nb_event = lttng_ht_get_count(agt->events); + rcu_read_unlock(); if (nb_event == 0) { ret = nb_event; + *total_size = 0; goto error; } - tmp_events = zmalloc(nb_event * sizeof(*tmp_events)); + /* Compute required extended infos size */ + extended_len = nb_event * sizeof(struct lttcomm_event_extended_header); + + /* + * This is only valid because the commands which add events are + * processed in the same thread as the listing. + */ + rcu_read_lock(); + cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { + ret = increment_extended_len(event->filter_expression, NULL, NULL, + &extended_len); + if (ret) { + DBG("Error computing the length of extended info message"); + ret = -LTTNG_ERR_FATAL; + goto error; + } + } + rcu_read_unlock(); + + *total_size = nb_event * sizeof(*tmp_events) + extended_len; + tmp_events = zmalloc(*total_size); if (!tmp_events) { PERROR("zmalloc agent events session"); ret = -LTTNG_ERR_FATAL; goto error; } + extended_at = ((uint8_t *) tmp_events) + + nb_event * sizeof(struct lttng_event); + rcu_read_lock(); cds_lfht_for_each_entry(agt->events->ht, &iter.iter, event, node.node) { strncpy(tmp_events[i].name, event->name, sizeof(tmp_events[i].name)); tmp_events[i].name[sizeof(tmp_events[i].name) - 1] = '\0'; tmp_events[i].enabled = event->enabled; - tmp_events[i].loglevel = event->loglevel; + tmp_events[i].loglevel = event->loglevel_value; tmp_events[i].loglevel_type = event->loglevel_type; i++; + + /* Append extended info */ + ret = append_extended_info(event->filter_expression, NULL, NULL, + &extended_at); + if (ret) { + DBG("Error appending extended info message"); + ret = -LTTNG_ERR_FATAL; + goto error; + } } - rcu_read_unlock(); *events = tmp_events; ret = nb_event; - -error: assert(nb_event == i); + +end: + rcu_read_unlock(); return ret; +error: + free(tmp_events); + goto end; } /* * Create a list of ust global domain events. */ static int list_lttng_ust_global_events(char *channel_name, - struct ltt_ust_domain_global *ust_global, struct lttng_event **events) + struct ltt_ust_domain_global *ust_global, + struct lttng_event **events, size_t *total_size) { int i = 0, ret = 0; unsigned int nb_event = 0; @@ -263,6 +584,8 @@ static int list_lttng_ust_global_events(char *channel_name, struct ltt_ust_channel *uchan; struct ltt_ust_event *uevent; struct lttng_event *tmp; + size_t extended_len = 0; + void *extended_at; DBG("Listing UST global events for channel %s", channel_name); @@ -272,27 +595,56 @@ static int list_lttng_ust_global_events(char *channel_name, node = lttng_ht_iter_get_node_str(&iter); if (node == NULL) { ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; - goto error; + goto end; } uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node); - nb_event += lttng_ht_get_count(uchan->events); - + nb_event = lttng_ht_get_count(uchan->events); if (nb_event == 0) { ret = nb_event; - goto error; + *total_size = 0; + goto end; } DBG3("Listing UST global %d events", nb_event); - tmp = zmalloc(nb_event * sizeof(struct lttng_event)); + /* Compute required extended infos size */ + cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + if (uevent->internal) { + nb_event--; + continue; + } + + ret = increment_extended_len(uevent->filter_expression, + uevent->exclusion, NULL, &extended_len); + if (ret) { + DBG("Error computing the length of extended info message"); + ret = -LTTNG_ERR_FATAL; + goto end; + } + } + if (nb_event == 0) { + /* All events are internal, skip. */ + ret = 0; + *total_size = 0; + goto end; + } + + *total_size = nb_event * sizeof(struct lttng_event) + extended_len; + tmp = zmalloc(*total_size); if (tmp == NULL) { - ret = LTTNG_ERR_FATAL; - goto error; + ret = -LTTNG_ERR_FATAL; + goto end; } + extended_at = ((uint8_t *) tmp) + nb_event * sizeof(struct lttng_event); + cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) { + if (uevent->internal) { + /* This event should remain hidden from clients */ + continue; + } strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN); tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; tmp[i].enabled = uevent->enabled; @@ -328,12 +680,20 @@ static int list_lttng_ust_global_events(char *channel_name, tmp[i].exclusion = 1; } i++; + + /* Append extended info */ + ret = append_extended_info(uevent->filter_expression, + uevent->exclusion, NULL, &extended_at); + if (ret) { + DBG("Error appending extended info message"); + ret = -LTTNG_ERR_FATAL; + goto end; + } } ret = nb_event; *events = tmp; - -error: +end: rcu_read_unlock(); return ret; } @@ -342,12 +702,15 @@ error: * Fill lttng_event array of all kernel events in the channel. */ static int list_lttng_kernel_events(char *channel_name, - struct ltt_kernel_session *kernel_session, struct lttng_event **events) + struct ltt_kernel_session *kernel_session, + struct lttng_event **events, size_t *total_size) { int i = 0, ret; unsigned int nb_event; struct ltt_kernel_event *event; struct ltt_kernel_channel *kchan; + size_t extended_len = 0; + void *extended_at; kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session); if (kchan == NULL) { @@ -360,20 +723,40 @@ static int list_lttng_kernel_events(char *channel_name, DBG("Listing events for channel %s", kchan->channel->name); if (nb_event == 0) { + *total_size = 0; + *events = NULL; goto end; } - *events = zmalloc(nb_event * sizeof(struct lttng_event)); + /* Compute required extended infos size */ + cds_list_for_each_entry(event, &kchan->events_list.head, list) { + ret = increment_extended_len(event->filter_expression, NULL, + event->userspace_probe_location, + &extended_len); + if (ret) { + DBG("Error computing the length of extended info message"); + ret = -LTTNG_ERR_FATAL; + goto error; + } + } + + *total_size = nb_event * sizeof(struct lttng_event) + extended_len; + *events = zmalloc(*total_size); if (*events == NULL) { - ret = LTTNG_ERR_FATAL; + ret = -LTTNG_ERR_FATAL; goto error; } + extended_at = ((void *) *events) + + nb_event * sizeof(struct lttng_event); + /* Kernel channels */ cds_list_for_each_entry(event, &kchan->events_list.head , list) { strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; (*events)[i].enabled = event->enabled; + (*events)[i].filter = + (unsigned char) !!event->filter_expression; switch (event->event->instrumentation) { case LTTNG_KERNEL_TRACEPOINT: @@ -389,6 +772,9 @@ static int list_lttng_kernel_events(char *channel_name, memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; + case LTTNG_KERNEL_UPROBE: + (*events)[i].type = LTTNG_EVENT_USERSPACE_PROBE; + break; case LTTNG_KERNEL_FUNCTION: (*events)[i].type = LTTNG_EVENT_FUNCTION; memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, @@ -401,10 +787,21 @@ static int list_lttng_kernel_events(char *channel_name, (*events)[i].type = LTTNG_EVENT_SYSCALL; break; case LTTNG_KERNEL_ALL: + /* fall-through. */ + default: assert(0); break; } i++; + + /* Append extended info */ + ret = append_extended_info(event->filter_expression, NULL, + event->userspace_probe_location, &extended_at); + if (ret) { + DBG("Error appending extended info message"); + ret = -LTTNG_ERR_FATAL; + goto error; + } } end: @@ -420,7 +817,8 @@ error: * domain adding the default trace directory. */ static int add_uri_to_consumer(struct consumer_output *consumer, - struct lttng_uri *uri, int domain, const char *session_name) + struct lttng_uri *uri, enum lttng_domain_type domain, + const char *session_name) { int ret = LTTNG_OK; const char *default_trace_dir; @@ -499,14 +897,17 @@ static int add_uri_to_consumer(struct consumer_output *consumer, break; case LTTNG_DST_PATH: DBG2("Setting trace directory path from URI to %s", uri->dst.path); - memset(consumer->dst.trace_path, 0, - sizeof(consumer->dst.trace_path)); - strncpy(consumer->dst.trace_path, uri->dst.path, - sizeof(consumer->dst.trace_path)); + memset(consumer->dst.session_root_path, 0, + sizeof(consumer->dst.session_root_path)); + /* Explicit length checks for strcpy and strcat. */ + if (strlen(uri->dst.path) + strlen(default_trace_dir) + >= sizeof(consumer->dst.session_root_path)) { + ret = LTTNG_ERR_FATAL; + goto error; + } + strcpy(consumer->dst.session_root_path, uri->dst.path); /* Append default trace dir */ - strncat(consumer->dst.trace_path, default_trace_dir, - sizeof(consumer->dst.trace_path) - - strlen(consumer->dst.trace_path) - 1); + strcat(consumer->dst.session_root_path, default_trace_dir); /* Flag consumer as local. */ consumer->type = CONSUMER_DST_LOCAL; break; @@ -553,18 +954,20 @@ error: * Create a socket to the relayd using the URI. * * On success, the relayd_sock pointer is set to the created socket. - * Else, it's stays untouched and a lttcomm error code is returned. + * Else, it remains untouched and an LTTng error code is returned. */ -static int create_connect_relayd(struct lttng_uri *uri, - struct lttcomm_relayd_sock **relayd_sock) +static enum lttng_error_code create_connect_relayd(struct lttng_uri *uri, + struct lttcomm_relayd_sock **relayd_sock, + struct consumer_output *consumer) { int ret; + enum lttng_error_code status = LTTNG_OK; struct lttcomm_relayd_sock *rsock; rsock = lttcomm_alloc_relayd_sock(uri, RELAYD_VERSION_COMM_MAJOR, RELAYD_VERSION_COMM_MINOR); if (!rsock) { - ret = LTTNG_ERR_FATAL; + status = LTTNG_ERR_FATAL; goto error; } @@ -578,7 +981,7 @@ static int create_connect_relayd(struct lttng_uri *uri, health_poll_exit(); if (ret < 0) { ERR("Unable to reach lttng-relayd"); - ret = LTTNG_ERR_RELAYD_CONNECT_FAIL; + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto free_sock; } @@ -588,22 +991,28 @@ static int create_connect_relayd(struct lttng_uri *uri, /* Check relayd version */ ret = relayd_version_check(rsock); - if (ret < 0) { - ret = LTTNG_ERR_RELAYD_VERSION_FAIL; + if (ret == LTTNG_ERR_RELAYD_VERSION_FAIL) { + status = LTTNG_ERR_RELAYD_VERSION_FAIL; + goto close_sock; + } else if (ret < 0) { + ERR("Unable to reach lttng-relayd"); + status = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto close_sock; } + consumer->relay_major_version = rsock->major; + consumer->relay_minor_version = rsock->minor; } else if (uri->stype == LTTNG_STREAM_DATA) { DBG3("Creating relayd data socket from URI"); } else { /* Command is not valid */ ERR("Relayd invalid stream type: %d", uri->stype); - ret = LTTNG_ERR_INVALID; + status = LTTNG_ERR_INVALID; goto close_sock; } *relayd_sock = rsock; - return LTTNG_OK; + return status; close_sock: /* The returned value is not useful since we are on an error path. */ @@ -611,24 +1020,31 @@ close_sock: free_sock: free(rsock); error: - return ret; + return status; } /* * Connect to the relayd using URI and send the socket to the right consumer. + * + * The consumer socket lock must be held by the caller. + * + * Returns LTTNG_OK on success or an LTTng error code on failure. */ -static int send_consumer_relayd_socket(int domain, unsigned int session_id, - struct lttng_uri *relayd_uri, struct consumer_output *consumer, +static enum lttng_error_code send_consumer_relayd_socket( + unsigned int session_id, + struct lttng_uri *relayd_uri, + struct consumer_output *consumer, struct consumer_socket *consumer_sock, char *session_name, char *hostname, int session_live_timer) { int ret; struct lttcomm_relayd_sock *rsock = NULL; + enum lttng_error_code status; /* Connect to relayd and make version check if uri is the control. */ - ret = create_connect_relayd(relayd_uri, &rsock); - if (ret != LTTNG_OK) { - goto error; + status = create_connect_relayd(relayd_uri, &rsock, consumer); + if (status != LTTNG_OK) { + goto relayd_comm_error; } assert(rsock); @@ -649,7 +1065,7 @@ static int send_consumer_relayd_socket(int domain, unsigned int session_id, relayd_uri->stype, session_id, session_name, hostname, session_live_timer); if (ret < 0) { - ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL; + status = LTTNG_ERR_ENABLE_CONSUMER_FAIL; goto close_sock; } @@ -660,19 +1076,13 @@ static int send_consumer_relayd_socket(int domain, unsigned int session_id, consumer_sock->data_sock_sent = 1; } - ret = LTTNG_OK; - /* * Close socket which was dup on the consumer side. The session daemon does * NOT keep track of the relayd socket(s) once transfer to the consumer. */ close_sock: - (void) relayd_close(rsock); - free(rsock); - -error: - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { /* * The consumer output for this session should not be used anymore * since the relayd connection failed thus making any tracing or/and @@ -680,45 +1090,55 @@ error: */ consumer->enabled = 0; } - return ret; + (void) relayd_close(rsock); + free(rsock); + +relayd_comm_error: + return status; } /* * Send both relayd sockets to a specific consumer and domain. This is a * helper function to facilitate sending the information to the consumer for a * session. + * + * The consumer socket lock must be held by the caller. + * + * Returns LTTNG_OK, or an LTTng error code on failure. */ -static int send_consumer_relayd_sockets(int domain, unsigned int session_id, - struct consumer_output *consumer, struct consumer_socket *sock, - char *session_name, char *hostname, int session_live_timer) +static enum lttng_error_code send_consumer_relayd_sockets( + enum lttng_domain_type domain, + unsigned int session_id, struct consumer_output *consumer, + struct consumer_socket *sock, char *session_name, + char *hostname, int session_live_timer) { - int ret = LTTNG_OK; + enum lttng_error_code status = LTTNG_OK; assert(consumer); assert(sock); /* Sending control relayd socket. */ if (!sock->control_sock_sent) { - ret = send_consumer_relayd_socket(domain, session_id, + status = send_consumer_relayd_socket(session_id, &consumer->dst.net.control, consumer, sock, session_name, hostname, session_live_timer); - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { goto error; } } /* Sending data relayd socket. */ if (!sock->data_sock_sent) { - ret = send_consumer_relayd_socket(domain, session_id, + status = send_consumer_relayd_socket(session_id, &consumer->dst.net.data, consumer, sock, session_name, hostname, session_live_timer); - if (ret != LTTNG_OK) { + if (status != LTTNG_OK) { goto error; } } error: - return ret; + return status; } /* @@ -760,6 +1180,10 @@ int cmd_setup_relayd(struct ltt_session *session) /* Session is now ready for network streaming. */ session->net_handle = 1; } + session->consumer->relay_major_version = + usess->consumer->relay_major_version; + session->consumer->relay_minor_version = + usess->consumer->relay_minor_version; } if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET @@ -778,6 +1202,10 @@ int cmd_setup_relayd(struct ltt_session *session) /* Session is now ready for network streaming. */ session->net_handle = 1; } + session->consumer->relay_major_version = + ksess->consumer->relay_major_version; + session->consumer->relay_minor_version = + ksess->consumer->relay_minor_version; } error: @@ -840,7 +1268,7 @@ static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe) } /* Quiescent wait after starting trace */ - kernel_wait_quiescent(kernel_tracer_fd); + kernel_wait_quiescent(wpipe); ksess->active = 1; @@ -853,8 +1281,8 @@ error: /* * Command LTTNG_DISABLE_CHANNEL processed by the client thread. */ -int cmd_disable_channel(struct ltt_session *session, int domain, - char *channel_name) +int cmd_disable_channel(struct ltt_session *session, + enum lttng_domain_type domain, char *channel_name) { int ret; struct ltt_ust_session *usess; @@ -894,11 +1322,6 @@ int cmd_disable_channel(struct ltt_session *session, int domain, } break; } -#if 0 - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: -#endif default: ret = LTTNG_ERR_UNKNOWN_DOMAIN; goto error; @@ -912,24 +1335,136 @@ error: } /* - * Command LTTNG_ENABLE_CHANNEL processed by the client thread. + * Command LTTNG_TRACK_PID processed by the client thread. * - * The wpipe arguments is used as a notifier for the kernel thread. + * Called with session lock held. */ -int cmd_enable_channel(struct ltt_session *session, - struct lttng_domain *domain, struct lttng_channel *attr, int wpipe) +int cmd_track_pid(struct ltt_session *session, enum lttng_domain_type domain, + int pid) { int ret; - struct ltt_ust_session *usess = session->ust_session; - struct lttng_ht *chan_ht; - assert(session); - assert(attr); - assert(domain); + rcu_read_lock(); - DBG("Enabling channel %s for session %s", attr->name, session->name); + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_session *ksess; - rcu_read_lock(); + ksess = session->kernel_session; + + ret = kernel_track_pid(ksess, pid); + if (ret != LTTNG_OK) { + goto error; + } + + kernel_wait_quiescent(kernel_tracer_fd); + break; + } + case LTTNG_DOMAIN_UST: + { + struct ltt_ust_session *usess; + + usess = session->ust_session; + + ret = trace_ust_track_pid(usess, pid); + if (ret != LTTNG_OK) { + goto error; + } + break; + } + default: + ret = LTTNG_ERR_UNKNOWN_DOMAIN; + goto error; + } + + ret = LTTNG_OK; + +error: + rcu_read_unlock(); + return ret; +} + +/* + * Command LTTNG_UNTRACK_PID processed by the client thread. + * + * Called with session lock held. + */ +int cmd_untrack_pid(struct ltt_session *session, enum lttng_domain_type domain, + int pid) +{ + int ret; + + rcu_read_lock(); + + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_session *ksess; + + ksess = session->kernel_session; + + ret = kernel_untrack_pid(ksess, pid); + if (ret != LTTNG_OK) { + goto error; + } + + kernel_wait_quiescent(kernel_tracer_fd); + break; + } + case LTTNG_DOMAIN_UST: + { + struct ltt_ust_session *usess; + + usess = session->ust_session; + + ret = trace_ust_untrack_pid(usess, pid); + if (ret != LTTNG_OK) { + goto error; + } + break; + } + default: + ret = LTTNG_ERR_UNKNOWN_DOMAIN; + goto error; + } + + ret = LTTNG_OK; + +error: + rcu_read_unlock(); + return ret; +} + +/* + * Command LTTNG_ENABLE_CHANNEL processed by the client thread. + * + * The wpipe arguments is used as a notifier for the kernel thread. + */ +int cmd_enable_channel(struct ltt_session *session, + struct lttng_domain *domain, struct lttng_channel *attr, int wpipe) +{ + int ret; + struct ltt_ust_session *usess = session->ust_session; + struct lttng_ht *chan_ht; + size_t len; + + assert(session); + assert(attr); + assert(domain); + + len = lttng_strnlen(attr->name, sizeof(attr->name)); + + /* Validate channel name */ + if (attr->name[0] == '.' || + memchr(attr->name, '/', len) != NULL) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto end; + } + + DBG("Enabling channel %s for session %s", attr->name, session->name); + + rcu_read_lock(); /* * Don't try to enable a channel if the session has been started at @@ -950,13 +1485,33 @@ int cmd_enable_channel(struct ltt_session *session, attr->attr.switch_timer_interval = 0; } - /* - * The ringbuffer (both in user space and kernel) behave badly in overwrite - * mode and with less than 2 subbuf so block it right away and send back an - * invalid attribute error. - */ - if (attr->attr.overwrite && attr->attr.num_subbuf < 2) { - ret = LTTNG_ERR_INVALID; + /* Check for feature support */ + switch (domain->type) { + case LTTNG_DOMAIN_KERNEL: + { + if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 1) { + /* Sampling position of buffer is not supported */ + WARN("Kernel tracer does not support buffer monitoring. " + "Setting the monitor interval timer to 0 " + "(disabled) for channel '%s' of session '%s'", + attr-> name, session->name); + lttng_channel_set_monitor_timer_interval(attr, 0); + } + break; + } + case LTTNG_DOMAIN_UST: + break; + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: + if (!agent_tracing_is_enabled()) { + DBG("Attempted to enable a channel in an agent domain but the agent thread is not running"); + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; + goto error; + } + break; + default: + ret = LTTNG_ERR_UNKNOWN_DOMAIN; goto error; } @@ -984,9 +1539,40 @@ int cmd_enable_channel(struct ltt_session *session, break; } case LTTNG_DOMAIN_UST: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_PYTHON: { struct ltt_ust_channel *uchan; + /* + * FIXME + * + * Current agent implementation limitations force us to allow + * only one channel at once in "agent" subdomains. Each + * subdomain has a default channel name which must be strictly + * adhered to. + */ + if (domain->type == LTTNG_DOMAIN_JUL) { + if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME, + LTTNG_SYMBOL_NAME_LEN)) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto error; + } + } else if (domain->type == LTTNG_DOMAIN_LOG4J) { + if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME, + LTTNG_SYMBOL_NAME_LEN)) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto error; + } + } else if (domain->type == LTTNG_DOMAIN_PYTHON) { + if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME, + LTTNG_SYMBOL_NAME_LEN)) { + ret = LTTNG_ERR_INVALID_CHANNEL_NAME; + goto error; + } + } + chan_ht = usess->domain_global.channels; uchan = trace_ust_find_channel_by_name(chan_ht, attr->name); @@ -1007,15 +1593,15 @@ int cmd_enable_channel(struct ltt_session *session, error: rcu_read_unlock(); +end: return ret; } - /* * Command LTTNG_DISABLE_EVENT processed by the client thread. */ -int cmd_disable_event(struct ltt_session *session, int domain, - char *channel_name, +int cmd_disable_event(struct ltt_session *session, + enum lttng_domain_type domain, char *channel_name, struct lttng_event *event) { int ret; @@ -1025,13 +1611,11 @@ int cmd_disable_event(struct ltt_session *session, int domain, event_name = event->name; - if (event->loglevel_type || event->loglevel || event->enabled + /* Error out on unhandled search criteria */ + if (event->loglevel_type || event->loglevel != -1 || event->enabled || event->pid || event->filter || event->exclusion) { - return LTTNG_ERR_UNK; - } - /* Special handling for kernel domain all events. */ - if (domain == LTTNG_DOMAIN_KERNEL && !strcmp(event_name, "*")) { - return disable_kevent_all(session, domain, channel_name, event); + ret = LTTNG_ERR_UNK; + goto error; } rcu_read_lock(); @@ -1051,29 +1635,36 @@ int cmd_disable_event(struct ltt_session *session, int domain, */ if (ksess->has_non_default_channel && channel_name[0] == '\0') { ret = LTTNG_ERR_NEED_CHANNEL_NAME; - goto error; + goto error_unlock; } kchan = trace_kernel_get_channel_by_name(channel_name, ksess); if (kchan == NULL) { ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; - goto error; + goto error_unlock; } switch (event->type) { case LTTNG_EVENT_ALL: case LTTNG_EVENT_TRACEPOINT: - ret = event_kernel_disable_tracepoint(kchan, event_name); + case LTTNG_EVENT_SYSCALL: + case LTTNG_EVENT_PROBE: + case LTTNG_EVENT_FUNCTION: + case LTTNG_EVENT_FUNCTION_ENTRY:/* fall-through */ + if (event_name[0] == '\0') { + ret = event_kernel_disable_event(kchan, + NULL, event->type); + } else { + ret = event_kernel_disable_event(kchan, + event_name, event->type); + } if (ret != LTTNG_OK) { - goto error; + goto error_unlock; } break; - case LTTNG_EVENT_SYSCALL: - ret = event_kernel_disable_syscall(kchan, event_name); - break; default: ret = LTTNG_ERR_UNK; - goto error; + goto error_unlock; } kernel_wait_quiescent(kernel_tracer_fd); @@ -1086,33 +1677,47 @@ int cmd_disable_event(struct ltt_session *session, int domain, usess = session->ust_session; + if (validate_ust_event_name(event_name)) { + ret = LTTNG_ERR_INVALID_EVENT_NAME; + goto error_unlock; + } + /* * If a non-default channel has been created in the - * session, explicitely require that -c chan_name needs + * session, explicitly require that -c chan_name needs * to be provided. */ if (usess->has_non_default_channel && channel_name[0] == '\0') { ret = LTTNG_ERR_NEED_CHANNEL_NAME; - goto error; + goto error_unlock; } uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, channel_name); if (uchan == NULL) { ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; - goto error; + goto error_unlock; } switch (event->type) { case LTTNG_EVENT_ALL: - ret = event_ust_disable_tracepoint(usess, uchan, event_name); + /* + * An empty event name means that everything + * should be disabled. + */ + if (event->name[0] == '\0') { + ret = event_ust_disable_all_tracepoints(usess, uchan); + } else { + ret = event_ust_disable_tracepoint(usess, uchan, + event_name); + } if (ret != LTTNG_OK) { - goto error; + goto error_unlock; } break; default: ret = LTTNG_ERR_UNK; - goto error; + goto error_unlock; } DBG3("Disable UST event %s in channel %s completed", event_name, @@ -1121,6 +1726,7 @@ int cmd_disable_event(struct ltt_session *session, int domain, } case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: { struct agent *agt; struct ltt_ust_session *usess = session->ust_session; @@ -1132,119 +1738,65 @@ int cmd_disable_event(struct ltt_session *session, int domain, break; default: ret = LTTNG_ERR_UNK; - goto error; + goto error_unlock; } agt = trace_ust_find_agent(usess, domain); if (!agt) { ret = -LTTNG_ERR_UST_EVENT_NOT_FOUND; - goto error; + goto error_unlock; } - /* The wild card * means that everything should be disabled. */ - if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) { + /* + * An empty event name means that everything + * should be disabled. + */ + if (event->name[0] == '\0') { ret = event_agent_disable_all(usess, agt); } else { ret = event_agent_disable(usess, agt, event_name); } if (ret != LTTNG_OK) { - goto error; + goto error_unlock; } break; } -#if 0 - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: -#endif default: ret = LTTNG_ERR_UND; - goto error; + goto error_unlock; } ret = LTTNG_OK; -error: +error_unlock: rcu_read_unlock(); - return ret; -} - -/* - * Command LTTNG_DISABLE_EVENT for event "*" processed by the client thread. - */ -static -int disable_kevent_all(struct ltt_session *session, int domain, - char *channel_name, - struct lttng_event *event) -{ - int ret; - char *event_name; - - event_name = event->name; - - rcu_read_lock(); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess; - struct ltt_kernel_channel *kchan; - - ksess = session->kernel_session; - - /* - * If a non-default channel has been created in the - * session, explicitely require that -c chan_name needs - * to be provided. - */ - if (ksess->has_non_default_channel && channel_name[0] == '\0') { - ret = LTTNG_ERR_NEED_CHANNEL_NAME; - goto error; - } - - kchan = trace_kernel_get_channel_by_name(channel_name, ksess); - if (kchan == NULL) { - ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; - goto error; - } - - switch (event->type) { - case LTTNG_EVENT_ALL: - ret = event_kernel_disable_all(kchan); - if (ret != LTTNG_OK) { - goto error; - } - break; - case LTTNG_EVENT_SYSCALL: - ret = event_kernel_disable_syscall(kchan, event_name); - break; - default: - ret = LTTNG_ERR_UNK; - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - break; - } - default: - ret = LTTNG_ERR_UND; - goto error; - } - - ret = LTTNG_OK; - error: - rcu_read_unlock(); return ret; } /* * Command LTTNG_ADD_CONTEXT processed by the client thread. */ -int cmd_add_context(struct ltt_session *session, int domain, +int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, char *channel_name, struct lttng_event_context *ctx, int kwpipe) { int ret, chan_kern_created = 0, chan_ust_created = 0; + char *app_ctx_provider_name = NULL, *app_ctx_name = NULL; + + /* + * Don't try to add a context if the session has been started at + * some point in time before. The tracer does not allow it and would + * result in a corrupted trace. + */ + if (session->has_been_started) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto end; + } + + if (ctx->ctx == LTTNG_EVENT_CONTEXT_APP_CONTEXT) { + app_ctx_provider_name = ctx->u.app_ctx.provider_name; + app_ctx_name = ctx->u.app_ctx.ctx_name; + } switch (domain) { case LTTNG_DOMAIN_KERNEL: @@ -1264,6 +1816,29 @@ int cmd_add_context(struct ltt_session *session, int domain, goto error; } break; + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_LOG4J: + { + /* + * Validate channel name. + * If no channel name is given and the domain is JUL or LOG4J, + * set it to the appropriate domain-specific channel name. If + * a name is provided but does not match the expexted channel + * name, return an error. + */ + if (domain == LTTNG_DOMAIN_JUL && *channel_name && + strcmp(channel_name, + DEFAULT_JUL_CHANNEL_NAME)) { + ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; + } else if (domain == LTTNG_DOMAIN_LOG4J && *channel_name && + strcmp(channel_name, + DEFAULT_LOG4J_CHANNEL_NAME)) { + ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto error; + } + /* break is _not_ missing here. */ + } case LTTNG_DOMAIN_UST: { struct ltt_ust_session *usess = session->ust_session; @@ -1286,27 +1861,27 @@ int cmd_add_context(struct ltt_session *session, int domain, free(attr); goto error; } - free(attr); + channel_attr_destroy(attr); chan_ust_created = 1; } ret = context_ust_add(usess, domain, ctx, channel_name); + free(app_ctx_provider_name); + free(app_ctx_name); + app_ctx_name = NULL; + app_ctx_provider_name = NULL; if (ret != LTTNG_OK) { goto error; } break; } -#if 0 - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: -#endif default: ret = LTTNG_ERR_UND; goto error; } - return LTTNG_OK; + ret = LTTNG_OK; + goto end; error: if (chan_kern_created) { @@ -1330,71 +1905,83 @@ error: uchan); trace_ust_destroy_channel(uchan); } +end: + free(app_ctx_provider_name); + free(app_ctx_name); return ret; } -static int validate_event_name(const char *name) +static inline bool name_starts_with(const char *name, const char *prefix) +{ + const size_t max_cmp_len = min(strlen(prefix), LTTNG_SYMBOL_NAME_LEN); + + return !strncmp(name, prefix, max_cmp_len); +} + +/* Perform userspace-specific event name validation */ +static int validate_ust_event_name(const char *name) { int ret = 0; - const char *c = name; - const char *event_name_end = c + LTTNG_SYMBOL_NAME_LEN; + + if (!name) { + ret = -1; + goto end; + } /* - * Make sure that unescaped wildcards are only used as the last - * character of the event name. + * Check name against all internal UST event component namespaces used + * by the agents. */ - while (c < event_name_end) { - switch (*c) { - case '\0': - goto end; - case '\\': - c++; - break; - case '*': - if ((c + 1) < event_name_end && *(c + 1)) { - /* Wildcard is not the last character */ - ret = LTTNG_ERR_INVALID_EVENT_NAME; - goto end; - } - default: - break; - } - c++; + if (name_starts_with(name, DEFAULT_JUL_EVENT_COMPONENT) || + name_starts_with(name, DEFAULT_LOG4J_EVENT_COMPONENT) || + name_starts_with(name, DEFAULT_PYTHON_EVENT_COMPONENT)) { + ret = -1; } + end: return ret; } /* - * Command LTTNG_ENABLE_EVENT processed by the client thread. + * Internal version of cmd_enable_event() with a supplemental + * "internal_event" flag which is used to enable internal events which should + * be hidden from clients. Such events are used in the agent implementation to + * enable the events through which all "agent" events are funeled. */ -int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, +static int _cmd_enable_event(struct ltt_session *session, + struct lttng_domain *domain, char *channel_name, struct lttng_event *event, char *filter_expression, struct lttng_filter_bytecode *filter, struct lttng_event_exclusion *exclusion, - int wpipe) + int wpipe, bool internal_event) { - int ret, channel_created = 0; - struct lttng_channel *attr; + int ret = 0, channel_created = 0; + struct lttng_channel *attr = NULL; assert(session); assert(event); assert(channel_name); - DBG("Enable event command for event \'%s\'", event->name); + /* If we have a filter, we must have its filter expression */ + assert(!(!!filter_expression ^ !!filter)); - /* Special handling for kernel domain all events. */ - if (domain->type == LTTNG_DOMAIN_KERNEL && !strcmp(event->name, "*")) { - return enable_kevent_all(session, domain, channel_name, event, - filter_expression, filter, wpipe); - } + /* Normalize event name as a globbing pattern */ + strutils_normalize_star_glob_pattern(event->name); - ret = validate_event_name(event->name); - if (ret) { - goto error; + /* Normalize exclusion names as globbing patterns */ + if (exclusion) { + size_t i; + + for (i = 0; i < exclusion->count; i++) { + char *name = LTTNG_EVENT_EXCLUSION_NAME_AT(exclusion, i); + + strutils_normalize_star_glob_pattern(name); + } } + DBG("Enable event command for event \'%s\'", event->name); + rcu_read_lock(); switch (domain->type) { @@ -1422,15 +2009,16 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, ret = LTTNG_ERR_FATAL; goto error; } - strncpy(attr->name, channel_name, sizeof(attr->name)); + if (lttng_strncpy(attr->name, channel_name, + sizeof(attr->name))) { + ret = LTTNG_ERR_INVALID; + goto error; + } ret = cmd_enable_channel(session, domain, attr, wpipe); if (ret != LTTNG_OK) { - free(attr); goto error; } - free(attr); - channel_created = 1; } @@ -1445,8 +2033,67 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, switch (event->type) { case LTTNG_EVENT_ALL: + { + char *filter_expression_a = NULL; + struct lttng_filter_bytecode *filter_a = NULL; + + /* + * We need to duplicate filter_expression and filter, + * because ownership is passed to first enable + * event. + */ + if (filter_expression) { + filter_expression_a = strdup(filter_expression); + if (!filter_expression_a) { + ret = LTTNG_ERR_FATAL; + goto error; + } + } + if (filter) { + filter_a = zmalloc(sizeof(*filter_a) + filter->len); + if (!filter_a) { + free(filter_expression_a); + ret = LTTNG_ERR_FATAL; + goto error; + } + memcpy(filter_a, filter, sizeof(*filter_a) + filter->len); + } + event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */ + ret = event_kernel_enable_event(kchan, event, + filter_expression, filter); + /* We have passed ownership */ + filter_expression = NULL; + filter = NULL; + if (ret != LTTNG_OK) { + if (channel_created) { + /* Let's not leak a useless channel. */ + kernel_destroy_channel(kchan); + } + free(filter_expression_a); + free(filter_a); + goto error; + } + event->type = LTTNG_EVENT_SYSCALL; /* Hack */ + ret = event_kernel_enable_event(kchan, event, + filter_expression_a, filter_a); + /* We have passed ownership */ + filter_expression_a = NULL; + filter_a = NULL; + if (ret != LTTNG_OK) { + goto error; + } + break; + } + case LTTNG_EVENT_PROBE: + case LTTNG_EVENT_USERSPACE_PROBE: + case LTTNG_EVENT_FUNCTION: + case LTTNG_EVENT_FUNCTION_ENTRY: case LTTNG_EVENT_TRACEPOINT: - ret = event_kernel_enable_tracepoint(kchan, event); + ret = event_kernel_enable_event(kchan, event, + filter_expression, filter); + /* We have passed ownership */ + filter_expression = NULL; + filter = NULL; if (ret != LTTNG_OK) { if (channel_created) { /* Let's not leak a useless channel. */ @@ -1456,7 +2103,14 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, } break; case LTTNG_EVENT_SYSCALL: - ret = event_kernel_enable_syscall(kchan, event->name); + ret = event_kernel_enable_event(kchan, event, + filter_expression, filter); + /* We have passed ownership */ + filter_expression = NULL; + filter = NULL; + if (ret != LTTNG_OK) { + goto error; + } break; default: ret = LTTNG_ERR_UNK; @@ -1494,14 +2148,16 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, ret = LTTNG_ERR_FATAL; goto error; } - strncpy(attr->name, channel_name, sizeof(attr->name)); + if (lttng_strncpy(attr->name, channel_name, + sizeof(attr->name))) { + ret = LTTNG_ERR_INVALID; + goto error; + } ret = cmd_enable_channel(session, domain, attr, wpipe); if (ret != LTTNG_OK) { - free(attr); goto error; } - free(attr); /* Get the newly created channel reference back */ uchan = trace_ust_find_channel_by_name( @@ -1509,16 +2165,48 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, assert(uchan); } + if (uchan->domain != LTTNG_DOMAIN_UST && !internal_event) { + /* + * Don't allow users to add UST events to channels which + * are assigned to a userspace subdomain (JUL, Log4J, + * Python, etc.). + */ + ret = LTTNG_ERR_INVALID_CHANNEL_DOMAIN; + goto error; + } + + if (!internal_event) { + /* + * Ensure the event name is not reserved for internal + * use. + */ + ret = validate_ust_event_name(event->name); + if (ret) { + WARN("Userspace event name %s failed validation.", + event->name); + ret = LTTNG_ERR_INVALID_EVENT_NAME; + goto error; + } + } + /* At this point, the session and channel exist on the tracer */ ret = event_ust_enable_tracepoint(usess, uchan, event, - filter_expression, filter, exclusion); - if (ret != LTTNG_OK) { + filter_expression, filter, exclusion, + internal_event); + /* We have passed ownership */ + filter_expression = NULL; + filter = NULL; + exclusion = NULL; + if (ret == LTTNG_ERR_UST_EVENT_ENABLED) { + goto already_enabled; + } else if (ret != LTTNG_OK) { goto error; } break; } case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: { const char *default_event_name, *default_chan_name; struct agent *agt; @@ -1528,11 +2216,17 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, assert(usess); + if (!agent_tracing_is_enabled()) { + DBG("Attempted to enable an event in an agent domain but the agent thread is not running"); + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; + goto error; + } + agt = trace_ust_find_agent(usess, domain->type); if (!agt) { agt = agent_create(domain->type); if (!agt) { - ret = -LTTNG_ERR_NOMEM; + ret = LTTNG_ERR_NOMEM; goto error; } agent_add(agt, usess->agents); @@ -1542,9 +2236,10 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, memset(&uevent, 0, sizeof(uevent)); uevent.type = LTTNG_EVENT_TRACEPOINT; uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL; - default_event_name = event_get_default_agent_ust_name(domain->type); + default_event_name = event_get_default_agent_ust_name( + domain->type); if (!default_event_name) { - ret = -LTTNG_ERR_FATAL; + ret = LTTNG_ERR_FATAL; goto error; } strncpy(uevent.name, default_event_name, sizeof(uevent.name)); @@ -1558,35 +2253,78 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, memcpy(&tmp_dom, domain, sizeof(tmp_dom)); tmp_dom.type = LTTNG_DOMAIN_UST; - if (domain->type == LTTNG_DOMAIN_LOG4J) { + switch (domain->type) { + case LTTNG_DOMAIN_LOG4J: default_chan_name = DEFAULT_LOG4J_CHANNEL_NAME; - } else { + break; + case LTTNG_DOMAIN_JUL: default_chan_name = DEFAULT_JUL_CHANNEL_NAME; + break; + case LTTNG_DOMAIN_PYTHON: + default_chan_name = DEFAULT_PYTHON_CHANNEL_NAME; + break; + default: + /* The switch/case we are in makes this impossible */ + assert(0); + } + + { + char *filter_expression_copy = NULL; + struct lttng_filter_bytecode *filter_copy = NULL; + + if (filter) { + const size_t filter_size = sizeof( + struct lttng_filter_bytecode) + + filter->len; + + filter_copy = zmalloc(filter_size); + if (!filter_copy) { + ret = LTTNG_ERR_NOMEM; + goto error; + } + memcpy(filter_copy, filter, filter_size); + + filter_expression_copy = + strdup(filter_expression); + if (!filter_expression) { + ret = LTTNG_ERR_NOMEM; + } + + if (!filter_expression_copy || !filter_copy) { + free(filter_expression_copy); + free(filter_copy); + goto error; + } + } + + ret = cmd_enable_event_internal(session, &tmp_dom, + (char *) default_chan_name, + &uevent, filter_expression_copy, + filter_copy, NULL, wpipe); } - ret = cmd_enable_event(session, &tmp_dom, (char *) default_chan_name, - &uevent, filter_expression, filter, NULL, wpipe); - if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) { + if (ret == LTTNG_ERR_UST_EVENT_ENABLED) { + goto already_enabled; + } else if (ret != LTTNG_OK) { goto error; } /* The wild card * means that everything should be enabled. */ if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) { - ret = event_agent_enable_all(usess, agt, event, filter); + ret = event_agent_enable_all(usess, agt, event, filter, + filter_expression); } else { - ret = event_agent_enable(usess, agt, event, filter); + ret = event_agent_enable(usess, agt, event, filter, + filter_expression); } + filter = NULL; + filter_expression = NULL; if (ret != LTTNG_OK) { goto error; } break; } -#if 0 - case LTTNG_DOMAIN_UST_EXEC_NAME: - case LTTNG_DOMAIN_UST_PID: - case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN: -#endif default: ret = LTTNG_ERR_UND; goto error; @@ -1594,121 +2332,53 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, ret = LTTNG_OK; +already_enabled: error: + free(filter_expression); + free(filter); + free(exclusion); + channel_attr_destroy(attr); rcu_read_unlock(); return ret; } /* - * Command LTTNG_ENABLE_EVENT for event "*" processed by the client thread. + * Command LTTNG_ENABLE_EVENT processed by the client thread. + * We own filter, exclusion, and filter_expression. */ -static -int enable_kevent_all(struct ltt_session *session, - struct lttng_domain *domain, char *channel_name, - struct lttng_event *event, +int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, + char *channel_name, struct lttng_event *event, char *filter_expression, - struct lttng_filter_bytecode *filter, int wpipe) + struct lttng_filter_bytecode *filter, + struct lttng_event_exclusion *exclusion, + int wpipe) { - int ret; - struct lttng_channel *attr; - - assert(session); - assert(channel_name); - - rcu_read_lock(); - - switch (domain->type) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_channel *kchan; - - assert(session->kernel_session); - - /* - * If a non-default channel has been created in the - * session, explicitely require that -c chan_name needs - * to be provided. - */ - if (session->kernel_session->has_non_default_channel - && channel_name[0] == '\0') { - ret = LTTNG_ERR_NEED_CHANNEL_NAME; - goto error; - } - - kchan = trace_kernel_get_channel_by_name(channel_name, - session->kernel_session); - if (kchan == NULL) { - /* Create default channel */ - attr = channel_new_default_attr(LTTNG_DOMAIN_KERNEL, - LTTNG_BUFFER_GLOBAL); - if (attr == NULL) { - ret = LTTNG_ERR_FATAL; - goto error; - } - strncpy(attr->name, channel_name, sizeof(attr->name)); - - ret = cmd_enable_channel(session, domain, attr, wpipe); - if (ret != LTTNG_OK) { - free(attr); - goto error; - } - free(attr); - - /* Get the newly created kernel channel pointer */ - kchan = trace_kernel_get_channel_by_name(channel_name, - session->kernel_session); - assert(kchan); - } - - switch (event->type) { - case LTTNG_EVENT_SYSCALL: - ret = event_kernel_enable_syscall(kchan, ""); - break; - case LTTNG_EVENT_TRACEPOINT: - /* - * This call enables all LTTNG_KERNEL_TRACEPOINTS and - * events already registered to the channel. - */ - ret = event_kernel_enable_all_tracepoints(kchan, kernel_tracer_fd); - break; - case LTTNG_EVENT_ALL: - /* Enable syscalls and tracepoints */ - ret = event_kernel_enable_all(kchan, kernel_tracer_fd); - break; - default: - ret = LTTNG_ERR_KERN_ENABLE_FAIL; - goto error; - } - - /* Manage return value */ - if (ret != LTTNG_OK) { - /* - * On error, cmd_enable_channel call will take care of destroying - * the created channel if it was needed. - */ - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - break; - } - default: - ret = LTTNG_ERR_UND; - goto error; - } - - ret = LTTNG_OK; - -error: - rcu_read_unlock(); - return ret; + return _cmd_enable_event(session, domain, channel_name, event, + filter_expression, filter, exclusion, wpipe, false); } +/* + * Enable an event which is internal to LTTng. An internal should + * never be made visible to clients and are immune to checks such as + * reserved names. + */ +static int cmd_enable_event_internal(struct ltt_session *session, + struct lttng_domain *domain, + char *channel_name, struct lttng_event *event, + char *filter_expression, + struct lttng_filter_bytecode *filter, + struct lttng_event_exclusion *exclusion, + int wpipe) +{ + return _cmd_enable_event(session, domain, channel_name, event, + filter_expression, filter, exclusion, wpipe, true); +} /* * Command LTTNG_LIST_TRACEPOINTS processed by the client thread. */ -ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) +ssize_t cmd_list_tracepoints(enum lttng_domain_type domain, + struct lttng_event **events) { int ret; ssize_t nb_events = 0; @@ -1730,6 +2400,7 @@ ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) break; case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: nb_events = agent_list_events(events, domain); if (nb_events < 0) { ret = LTTNG_ERR_UST_LIST_FAIL; @@ -1751,7 +2422,7 @@ error: /* * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread. */ -ssize_t cmd_list_tracepoint_fields(int domain, +ssize_t cmd_list_tracepoint_fields(enum lttng_domain_type domain, struct lttng_event_field **fields) { int ret; @@ -1778,70 +2449,274 @@ error: return -ret; } +ssize_t cmd_list_syscalls(struct lttng_event **events) +{ + return syscall_table_list(events); +} + /* - * Command LTTNG_START_TRACE processed by the client thread. + * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread. + * + * Called with session lock held. */ -int cmd_start_trace(struct ltt_session *session) +ssize_t cmd_list_tracker_pids(struct ltt_session *session, + enum lttng_domain_type domain, int32_t **pids) { int ret; - unsigned long nb_chan = 0; - struct ltt_kernel_session *ksession; - struct ltt_ust_session *usess; - - assert(session); - - /* Ease our life a bit ;) */ - ksession = session->kernel_session; - usess = session->ust_session; - - /* Is the session already started? */ - if (session->active) { - ret = LTTNG_ERR_TRACE_ALREADY_STARTED; - goto error; - } + ssize_t nr_pids = 0; - /* - * Starting a session without channel is useless since after that it's not - * possible to enable channel thus inform the client. - */ - if (usess && usess->domain_global.channels) { - nb_chan += lttng_ht_get_count(usess->domain_global.channels); - } - if (ksession) { - nb_chan += ksession->channel_count; - } - if (!nb_chan) { - ret = LTTNG_ERR_NO_CHANNEL; - goto error; - } + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + { + struct ltt_kernel_session *ksess; - /* Kernel tracing */ - if (ksession != NULL) { - ret = start_kernel_session(ksession, kernel_tracer_fd); - if (ret != LTTNG_OK) { + ksess = session->kernel_session; + nr_pids = kernel_list_tracker_pids(ksess, pids); + if (nr_pids < 0) { + ret = LTTNG_ERR_KERN_LIST_FAIL; goto error; } + break; } + case LTTNG_DOMAIN_UST: + { + struct ltt_ust_session *usess; - /* Flag session that trace should start automatically */ - if (usess) { - /* - * Even though the start trace might fail, flag this session active so - * other application coming in are started by default. - */ - usess->active = 1; - - ret = ust_app_start_trace_all(usess); - if (ret < 0) { - ret = LTTNG_ERR_UST_START_FAIL; + usess = session->ust_session; + nr_pids = trace_ust_list_tracker_pids(usess, pids); + if (nr_pids < 0) { + ret = LTTNG_ERR_UST_LIST_FAIL; goto error; } + break; + } + case LTTNG_DOMAIN_LOG4J: + case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: + default: + ret = LTTNG_ERR_UND; + goto error; } - /* Flag this after a successful start. */ + return nr_pids; + +error: + /* Return negative value to differentiate return code */ + return -ret; +} + +static +int domain_mkdir(const struct consumer_output *output, + const struct ltt_session *session, + uid_t uid, gid_t gid) +{ + struct consumer_socket *socket; + struct lttng_ht_iter iter; + int ret; + char *path = NULL; + + if (!output || !output->socks) { + ERR("No consumer output found"); + ret = -1; + goto end; + } + + path = zmalloc(LTTNG_PATH_MAX * sizeof(char)); + if (!path) { + ERR("Cannot allocate mkdir path"); + ret = -1; + goto end; + } + + ret = snprintf(path, LTTNG_PATH_MAX, "%s%s%s", + session_get_base_path(session), + output->chunk_path, output->subdir); + if (ret < 0 || ret >= LTTNG_PATH_MAX) { + ERR("Format path"); + ret = -1; + goto end; + } + + DBG("Domain mkdir %s for session %" PRIu64, path, session->id); + rcu_read_lock(); + /* + * We have to iterate to find a socket, but we only need to send the + * rename command to one consumer, so we break after the first one. + */ + cds_lfht_for_each_entry(output->socks->ht, &iter.iter, socket, node.node) { + pthread_mutex_lock(socket->lock); + ret = consumer_mkdir(socket, session->id, output, path, uid, gid); + pthread_mutex_unlock(socket->lock); + if (ret) { + ERR("Consumer mkdir"); + ret = -1; + goto end_unlock; + } + break; + } + + ret = 0; + +end_unlock: + rcu_read_unlock(); +end: + free(path); + return ret; +} + +static +int session_mkdir(const struct ltt_session *session) +{ + int ret; + struct consumer_output *output; + uid_t uid; + gid_t gid; + + /* + * Unsupported feature in lttng-relayd before 2.11, not an error since it + * is only needed for session rotation and the user will get an error + * on rotate. + */ + if (session->consumer->type == CONSUMER_DST_NET && + session->consumer->relay_major_version == 2 && + session->consumer->relay_minor_version < 11) { + ret = 0; + goto end; + } + + if (session->kernel_session) { + output = session->kernel_session->consumer; + uid = session->kernel_session->uid; + gid = session->kernel_session->gid; + ret = domain_mkdir(output, session, uid, gid); + if (ret) { + ERR("Mkdir kernel"); + goto end; + } + } + + if (session->ust_session) { + output = session->ust_session->consumer; + uid = session->ust_session->uid; + gid = session->ust_session->gid; + ret = domain_mkdir(output, session, uid, gid); + if (ret) { + ERR("Mkdir UST"); + goto end; + } + } + + ret = 0; + +end: + return ret; +} + +/* + * Command LTTNG_START_TRACE processed by the client thread. + * + * Called with session mutex held. + */ +int cmd_start_trace(struct ltt_session *session) +{ + int ret; + unsigned long nb_chan = 0; + struct ltt_kernel_session *ksession; + struct ltt_ust_session *usess; + + assert(session); + + /* Ease our life a bit ;) */ + ksession = session->kernel_session; + usess = session->ust_session; + + /* Is the session already started? */ + if (session->active) { + ret = LTTNG_ERR_TRACE_ALREADY_STARTED; + goto error; + } + + /* + * Starting a session without channel is useless since after that it's not + * possible to enable channel thus inform the client. + */ + if (usess && usess->domain_global.channels) { + nb_chan += lttng_ht_get_count(usess->domain_global.channels); + } + if (ksession) { + nb_chan += ksession->channel_count; + } + if (!nb_chan) { + ret = LTTNG_ERR_NO_CHANNEL; + goto error; + } + + /* + * Record the timestamp of the first time the session is started for + * an eventual session rotation call. + */ + if (!session->has_been_started) { + session->current_chunk_start_ts = time(NULL); + if (session->current_chunk_start_ts == (time_t) -1) { + PERROR("Failed to retrieve the \"%s\" session's start time", + session->name); + ret = LTTNG_ERR_FATAL; + goto error; + } + if (!session->snapshot_mode && session->output_traces) { + ret = session_mkdir(session); + if (ret) { + ERR("Failed to create the session directories"); + ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + } + } + + /* Kernel tracing */ + if (ksession != NULL) { + DBG("Start kernel tracing session %s", session->name); + ret = start_kernel_session(ksession, kernel_tracer_fd); + if (ret != LTTNG_OK) { + goto error; + } + } + + /* Flag session that trace should start automatically */ + if (usess) { + /* + * Even though the start trace might fail, flag this session active so + * other application coming in are started by default. + */ + usess->active = 1; + + ret = ust_app_start_trace_all(usess); + if (ret < 0) { + ret = LTTNG_ERR_UST_START_FAIL; + goto error; + } + } + + /* Flag this after a successful start. */ session->has_been_started = 1; session->active = 1; + /* + * Clear the flag that indicates that a rotation was done while the + * session was stopped. + */ + session->rotated_after_last_stop = false; + + if (session->rotate_timer_period) { + ret = timer_session_rotation_schedule_timer_start(session, + session->rotate_timer_period); + if (ret < 0) { + ERR("Failed to enable rotate timer"); + ret = LTTNG_ERR_UNK; + goto error; + } + } + ret = LTTNG_OK; error: @@ -1857,9 +2732,11 @@ int cmd_stop_trace(struct ltt_session *session) struct ltt_kernel_channel *kchan; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; + bool error_occurred = false; assert(session); + DBG("Begin stop session %s (id %" PRIu64 ")", session->name, session->id); /* Short cut */ ksession = session->kernel_session; usess = session->ust_session; @@ -1874,7 +2751,15 @@ int cmd_stop_trace(struct ltt_session *session) if (ksession && ksession->active) { DBG("Stop kernel tracing"); - /* Flush metadata if exist */ + ret = kernel_stop_session(ksession); + if (ret < 0) { + ret = LTTNG_ERR_KERN_STOP_FAIL; + goto error; + } + + kernel_wait_quiescent(kernel_tracer_fd); + + /* Flush metadata after stopping (if exists) */ if (ksession->metadata_stream_fd >= 0) { ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd); if (ret < 0) { @@ -1882,7 +2767,7 @@ int cmd_stop_trace(struct ltt_session *session) } } - /* Flush all buffers before stopping */ + /* Flush all buffers after stopping */ cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) { ret = kernel_flush_buffer(kchan); if (ret < 0) { @@ -1890,15 +2775,9 @@ int cmd_stop_trace(struct ltt_session *session) } } - ret = kernel_stop_session(ksession); - if (ret < 0) { - ret = LTTNG_ERR_KERN_STOP_FAIL; - goto error; - } - - kernel_wait_quiescent(kernel_tracer_fd); - ksession->active = 0; + DBG("Kernel session stopped %s (id %" PRIu64 ")", session->name, + session->id); } if (usess && usess->active) { @@ -1917,7 +2796,7 @@ int cmd_stop_trace(struct ltt_session *session) /* Flag inactive after a successful stop. */ session->active = 0; - ret = LTTNG_OK; + ret = !error_occurred ? LTTNG_OK : LTTNG_ERR_UNK; error: return ret; @@ -1926,13 +2805,12 @@ error: /* * Command LTTNG_SET_CONSUMER_URI processed by the client thread. */ -int cmd_set_consumer_uri(int domain, struct ltt_session *session, - size_t nb_uri, struct lttng_uri *uris) +int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, + struct lttng_uri *uris) { int ret, i; struct ltt_kernel_session *ksess = session->kernel_session; struct ltt_ust_session *usess = session->ust_session; - struct consumer_output *consumer = NULL; assert(session); assert(uris); @@ -1944,41 +2822,41 @@ int cmd_set_consumer_uri(int domain, struct ltt_session *session, goto error; } - /* - * This case switch makes sure the domain session has a temporary consumer - * so the URL can be set. - */ - switch (domain) { - case 0: - /* Code flow error. A session MUST always have a consumer object */ - assert(session->consumer); - /* - * The URL will be added to the tracing session consumer instead of a - * specific domain consumer. - */ - consumer = session->consumer; - break; - case LTTNG_DOMAIN_KERNEL: - /* Code flow error if we don't have a kernel session here. */ - assert(ksess); - assert(ksess->consumer); - consumer = ksess->consumer; - break; - case LTTNG_DOMAIN_UST: - /* Code flow error if we don't have a kernel session here. */ - assert(usess); - assert(usess->consumer); - consumer = usess->consumer; - break; - } - + /* Set the "global" consumer URIs */ for (i = 0; i < nb_uri; i++) { - ret = add_uri_to_consumer(consumer, &uris[i], domain, session->name); + ret = add_uri_to_consumer(session->consumer, + &uris[i], 0, session->name); if (ret != LTTNG_OK) { goto error; } } + /* Set UST session URIs */ + if (session->ust_session) { + for (i = 0; i < nb_uri; i++) { + ret = add_uri_to_consumer( + session->ust_session->consumer, + &uris[i], LTTNG_DOMAIN_UST, + session->name); + if (ret != LTTNG_OK) { + goto error; + } + } + } + + /* Set kernel session URIs */ + if (session->kernel_session) { + for (i = 0; i < nb_uri; i++) { + ret = add_uri_to_consumer( + session->kernel_session->consumer, + &uris[i], LTTNG_DOMAIN_KERNEL, + session->name); + if (ret != LTTNG_OK) { + goto error; + } + } + } + /* * Make sure to set the session in output mode after we set URI since a * session can be created without URL (thus flagged in no output mode). @@ -1986,7 +2864,9 @@ int cmd_set_consumer_uri(int domain, struct ltt_session *session, session->output_traces = 1; if (ksess) { ksess->output_traces = 1; - } else if (usess) { + } + + if (usess) { usess->output_traces = 1; } @@ -2004,39 +2884,31 @@ int cmd_create_session_uri(char *name, struct lttng_uri *uris, size_t nb_uri, lttng_sock_cred *creds, unsigned int live_timer) { int ret; - struct ltt_session *session; + struct ltt_session *session = NULL; assert(name); assert(creds); - /* - * Verify if the session already exist - * - * XXX: There is no need for the session lock list here since the caller - * (process_client_msg) is holding it. We might want to change that so a - * single command does not lock the entire session list. - */ + /* Check if the session already exists. */ + session_lock_list(); session = session_find_by_name(name); + session_unlock_list(); if (session != NULL) { ret = LTTNG_ERR_EXIST_SESS; - goto find_error; + goto end; } /* Create tracing session in the registry */ ret = session_create(name, LTTNG_SOCK_GET_UID_CRED(creds), LTTNG_SOCK_GET_GID_CRED(creds)); if (ret != LTTNG_OK) { - goto session_error; + goto end; } - /* - * Get the newly created session pointer back - * - * XXX: There is no need for the session lock list here since the caller - * (process_client_msg) is holding it. We might want to change that so a - * single command does not lock the entire session list. - */ + /* Get the newly created session pointer back. */ + session_lock_list(); session = session_find_by_name(name); + session_unlock_list(); assert(session); session->live_timer = live_timer; @@ -2044,13 +2916,13 @@ int cmd_create_session_uri(char *name, struct lttng_uri *uris, session->consumer = consumer_create_output(CONSUMER_DST_LOCAL); if (session->consumer == NULL) { ret = LTTNG_ERR_FATAL; - goto consumer_error; + goto end; } if (uris) { - ret = cmd_set_consumer_uri(0, session, nb_uri, uris); + ret = cmd_set_consumer_uri(session, nb_uri, uris); if (ret != LTTNG_OK) { - goto consumer_error; + goto end; } session->output_traces = 1; } else { @@ -2060,12 +2932,13 @@ int cmd_create_session_uri(char *name, struct lttng_uri *uris, session->consumer->enabled = 1; - return LTTNG_OK; - -consumer_error: - session_destroy(session); -session_error: -find_error: + ret = LTTNG_OK; +end: + if (session) { + session_lock_list(); + session_put(session); + session_unlock_list(); + } return ret; } @@ -2076,7 +2949,7 @@ int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, size_t nb_uri, lttng_sock_cred *creds) { int ret; - struct ltt_session *session; + struct ltt_session *session = NULL; struct snapshot_output *new_output = NULL; assert(name); @@ -2086,13 +2959,15 @@ int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, * Create session in no output mode with URIs set to NULL. The uris we've * received are for a default snapshot output if one. */ - ret = cmd_create_session_uri(name, NULL, 0, creds, -1); + ret = cmd_create_session_uri(name, NULL, 0, creds, 0); if (ret != LTTNG_OK) { - goto error; + goto end; } /* Get the newly created session pointer back. This should NEVER fail. */ + session_lock_list(); session = session_find_by_name(name); + session_unlock_list(); assert(session); /* Flag session for snapshot mode. */ @@ -2100,6 +2975,7 @@ int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, /* Skip snapshot output creation if no URI is given. */ if (nb_uri == 0) { + /* Not an error. */ goto end; } @@ -2124,129 +3000,146 @@ int cmd_create_session_snapshot(char *name, struct lttng_uri *uris, snapshot_add_output(&session->snapshot, new_output); rcu_read_unlock(); -end: - return LTTNG_OK; + ret = LTTNG_OK; + goto end; error_snapshot: snapshot_output_destroy(new_output); error_snapshot_alloc: - session_destroy(session); -error: +end: + if (session) { + session_lock_list(); + session_put(session); + session_unlock_list(); + } return ret; } /* * Command LTTNG_DESTROY_SESSION processed by the client thread. + * + * Called with session lock held. */ -int cmd_destroy_session(struct ltt_session *session, int wpipe) +int cmd_destroy_session(struct ltt_session *session, + struct notification_thread_handle *notification_thread_handle) { int ret; - struct ltt_ust_session *usess; - struct ltt_kernel_session *ksess; /* Safety net */ assert(session); - usess = session->ust_session; - ksess = session->kernel_session; + DBG("Begin destroy session %s (id %" PRIu64 ")", session->name, session->id); - /* Clean kernel session teardown */ - kernel_destroy_session(ksess); + if (session->rotation_schedule_timer_enabled) { + if (timer_session_rotation_schedule_timer_stop( + session)) { + ERR("Failed to stop the \"rotation schedule\" timer of session %s", + session->name); + } + } - /* UST session teardown */ - if (usess) { - /* Close any relayd session */ - consumer_output_send_destroy_relayd(usess->consumer); + if (session->rotate_size) { + unsubscribe_session_consumed_size_rotation(session, notification_thread_handle); + session->rotate_size = 0; + } - /* Destroy every UST application related to this session. */ - ret = ust_app_destroy_trace_all(usess); - if (ret) { - ERR("Error in ust_app_destroy_trace_all"); + if (session->current_archive_id != 0) { + if (!session->rotated_after_last_stop) { + ret = cmd_rotate_session(session, NULL); + if (ret != LTTNG_OK) { + ERR("Failed to perform an implicit rotation as part of the rotation: %s", lttng_strerror(-ret)); + } + } else { + /* + * Rename the active chunk to ensure it has a name + * of the form ts_begin-ts_end-id. + * + * Note that no trace data has been produced since + * the last rotation; the directory should be + * removed. + */ + ret = rename_active_chunk(session); + if (ret) { + ERR("Failed to rename active chunk during the destruction of session \"%s\"", + session->name); + } } + } - /* Clean up the rest. */ - trace_ust_destroy_session(usess); + if (session->shm_path[0]) { + /* + * When a session is created with an explicit shm_path, + * the consumer daemon will create its shared memory files + * at that location and will *not* unlink them. This is normal + * as the intention of that feature is to make it possible + * to retrieve the content of those files should a crash occur. + * + * To ensure the content of those files can be used, the + * sessiond daemon will replicate the content of the metadata + * cache in a metadata file. + * + * On clean-up, it is expected that the consumer daemon will + * unlink the shared memory files and that the session daemon + * will unlink the metadata file. Then, the session's directory + * in the shm path can be removed. + * + * Unfortunately, a flaw in the design of the sessiond's and + * consumerd's tear down of channels makes it impossible to + * determine when the sessiond _and_ the consumerd have both + * destroyed their representation of a channel. For one, the + * unlinking, close, and rmdir happen in deferred 'call_rcu' + * callbacks in both daemons. + * + * However, it is also impossible for the sessiond to know when + * the consumer daemon is done destroying its channel(s) since + * it occurs as a reaction to the closing of the channel's file + * descriptor. There is no resulting communication initiated + * from the consumerd to the sessiond to confirm that the + * operation is completed (and was successful). + * + * Until this is all fixed, the session daemon checks for the + * removal of the session's shm path which makes it possible + * to safely advertise a session as having been destroyed. + * + * Prior to this fix, it was not possible to reliably save + * a session making use of the --shm-path option, destroy it, + * and load it again. This is because the creation of the + * session would fail upon seeing the session's shm path + * already in existence. + * + * Note that none of the error paths in the check for the + * directory's existence return an error. This is normal + * as there isn't much that can be done. The session will + * be destroyed properly, except that we can't offer the + * guarantee that the same session can be re-created. + */ + current_completion_handler = &destroy_completion_handler.handler; + ret = lttng_strncpy(destroy_completion_handler.shm_path, + session->shm_path, + sizeof(destroy_completion_handler.shm_path)); + assert(!ret); } /* - * Must notify the kernel thread here to update it's poll set in order to - * remove the channel(s)' fd just destroyed. + * The session is destroyed. However, note that the command context + * still holds a reference to the session, thus delaying its destruction + * _at least_ up to the point when that reference is released. */ - ret = notify_thread_pipe(wpipe); - if (ret < 0) { - PERROR("write kernel poll pipe"); - } - - ret = session_destroy(session); + session_destroy(session); + ret = LTTNG_OK; return ret; } /* - * Command LTTNG_CALIBRATE processed by the client thread. + * Command LTTNG_REGISTER_CONSUMER processed by the client thread. */ -int cmd_calibrate(int domain, struct lttng_calibrate *calibrate) +int cmd_register_consumer(struct ltt_session *session, + enum lttng_domain_type domain, const char *sock_path, + struct consumer_data *cdata) { - int ret; - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct lttng_kernel_calibrate kcalibrate; - - switch (calibrate->type) { - case LTTNG_CALIBRATE_FUNCTION: - default: - /* Default and only possible calibrate option. */ - kcalibrate.type = LTTNG_KERNEL_CALIBRATE_KRETPROBE; - break; - } - - ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate); - if (ret < 0) { - ret = LTTNG_ERR_KERN_ENABLE_FAIL; - goto error; - } - break; - } - case LTTNG_DOMAIN_UST: - { - struct lttng_ust_calibrate ucalibrate; - - switch (calibrate->type) { - case LTTNG_CALIBRATE_FUNCTION: - default: - /* Default and only possible calibrate option. */ - ucalibrate.type = LTTNG_UST_CALIBRATE_TRACEPOINT; - break; - } - - ret = ust_app_calibrate_glb(&ucalibrate); - if (ret < 0) { - ret = LTTNG_ERR_UST_CALIBRATE_FAIL; - goto error; - } - break; - } - default: - ret = LTTNG_ERR_UND; - goto error; - } - - ret = LTTNG_OK; - -error: - return ret; -} - -/* - * Command LTTNG_REGISTER_CONSUMER processed by the client thread. - */ -int cmd_register_consumer(struct ltt_session *session, int domain, - const char *sock_path, struct consumer_data *cdata) -{ - int ret, sock; - struct consumer_socket *socket = NULL; + int ret, sock; + struct consumer_socket *socket = NULL; assert(session); assert(cdata); @@ -2337,12 +3230,18 @@ ssize_t cmd_list_domains(struct ltt_session *session, DBG3("Listing domains found UST global domain"); nb_dom++; + rcu_read_lock(); cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, agt, node.node) { if (agt->being_used) { nb_dom++; } } + rcu_read_unlock(); + } + + if (!nb_dom) { + goto end; } *domains = zmalloc(nb_dom * sizeof(struct lttng_domain)); @@ -2353,6 +3252,10 @@ ssize_t cmd_list_domains(struct ltt_session *session, if (session->kernel_session != NULL) { (*domains)[index].type = LTTNG_DOMAIN_KERNEL; + + /* Kernel session buffer type is always GLOBAL */ + (*domains)[index].buf_type = LTTNG_BUFFER_GLOBAL; + index++; } @@ -2361,6 +3264,7 @@ ssize_t cmd_list_domains(struct ltt_session *session, (*domains)[index].buf_type = session->ust_session->buffer_type; index++; + rcu_read_lock(); cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, agt, node.node) { if (agt->being_used) { @@ -2369,8 +3273,9 @@ ssize_t cmd_list_domains(struct ltt_session *session, index++; } } + rcu_read_unlock(); } - +end: return nb_dom; error: @@ -2382,11 +3287,10 @@ error: /* * Command LTTNG_LIST_CHANNELS processed by the client thread. */ -ssize_t cmd_list_channels(int domain, struct ltt_session *session, - struct lttng_channel **channels) +ssize_t cmd_list_channels(enum lttng_domain_type domain, + struct ltt_session *session, struct lttng_channel **channels) { - int ret; - ssize_t nb_chan = 0; + ssize_t nb_chan = 0, payload_size = 0, ret; switch (domain) { case LTTNG_DOMAIN_KERNEL: @@ -2395,51 +3299,63 @@ ssize_t cmd_list_channels(int domain, struct ltt_session *session, } DBG3("Number of kernel channels %zd", nb_chan); if (nb_chan <= 0) { - ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND; + ret = -LTTNG_ERR_KERN_CHAN_NOT_FOUND; + goto end; } break; case LTTNG_DOMAIN_UST: if (session->ust_session != NULL) { + rcu_read_lock(); nb_chan = lttng_ht_get_count( - session->ust_session->domain_global.channels); + session->ust_session->domain_global.channels); + rcu_read_unlock(); } DBG3("Number of UST global channels %zd", nb_chan); - if (nb_chan <= 0) { - ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; + if (nb_chan < 0) { + ret = -LTTNG_ERR_UST_CHAN_NOT_FOUND; + goto end; } break; default: - *channels = NULL; - ret = LTTNG_ERR_UND; - goto error; + ret = -LTTNG_ERR_UND; + goto end; } if (nb_chan > 0) { - *channels = zmalloc(nb_chan * sizeof(struct lttng_channel)); + const size_t channel_size = sizeof(struct lttng_channel) + + sizeof(struct lttng_channel_extended); + struct lttng_channel_extended *channel_exts; + + payload_size = nb_chan * channel_size; + *channels = zmalloc(payload_size); if (*channels == NULL) { - ret = LTTNG_ERR_FATAL; - goto error; + ret = -LTTNG_ERR_FATAL; + goto end; } - list_lttng_channels(domain, session, *channels); + channel_exts = ((void *) *channels) + + (nb_chan * sizeof(struct lttng_channel)); + ret = list_lttng_channels(domain, session, *channels, channel_exts); + if (ret != LTTNG_OK) { + free(*channels); + *channels = NULL; + goto end; + } } else { *channels = NULL; - /* Ret value was set in the domain switch case */ - goto error; } - return nb_chan; - -error: - /* Return negative value to differentiate return code */ - return -ret; + ret = payload_size; +end: + return ret; } /* * Command LTTNG_LIST_EVENTS processed by the client thread. */ -ssize_t cmd_list_events(int domain, struct ltt_session *session, - char *channel_name, struct lttng_event **events) +ssize_t cmd_list_events(enum lttng_domain_type domain, + struct ltt_session *session, char *channel_name, + struct lttng_event **events, size_t *total_size) { int ret = 0; ssize_t nb_event = 0; @@ -2448,27 +3364,37 @@ ssize_t cmd_list_events(int domain, struct ltt_session *session, case LTTNG_DOMAIN_KERNEL: if (session->kernel_session != NULL) { nb_event = list_lttng_kernel_events(channel_name, - session->kernel_session, events); + session->kernel_session, events, + total_size); } break; case LTTNG_DOMAIN_UST: { if (session->ust_session != NULL) { nb_event = list_lttng_ust_global_events(channel_name, - &session->ust_session->domain_global, events); + &session->ust_session->domain_global, events, + total_size); } break; } case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_JUL: + case LTTNG_DOMAIN_PYTHON: if (session->ust_session) { struct lttng_ht_iter iter; struct agent *agt; + rcu_read_lock(); cds_lfht_for_each_entry(session->ust_session->agents->ht, &iter.iter, agt, node.node) { - nb_event = list_lttng_agent_events(agt, events); + if (agt->domain == domain) { + nb_event = list_lttng_agent_events( + agt, events, + total_size); + break; + } } + rcu_read_unlock(); } break; default: @@ -2505,10 +3431,15 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, * the buffer. */ cds_list_for_each_entry(session, &list->head, list) { + if (!session_get(session)) { + continue; + } /* * Only list the sessions the user can control. */ - if (!session_access_ok(session, uid, gid)) { + if (!session_access_ok(session, uid, gid) || + session->destroyed) { + session_put(session); continue; } @@ -2522,10 +3453,11 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, sizeof(sessions[i].path), session); } else { ret = snprintf(sessions[i].path, sizeof(sessions[i].path), "%s", - session->consumer->dst.trace_path); + session->consumer->dst.session_root_path); } if (ret < 0) { PERROR("snprintf session path"); + session_put(session); continue; } @@ -2535,6 +3467,7 @@ void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid, sessions[i].snapshot_mode = session->snapshot_mode; sessions[i].live_timer_interval = session->live_timer; i++; + session_put(session); } } @@ -2550,6 +3483,8 @@ int cmd_data_pending(struct ltt_session *session) assert(session); + DBG("Data pending for session %s", session->name); + /* Session MUST be stopped to ask for data availability. */ if (session->active) { ret = LTTNG_ERR_SESSION_STARTED; @@ -2571,6 +3506,13 @@ int cmd_data_pending(struct ltt_session *session) } } + /* A rotation is still pending, we have to wait. */ + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) { + DBG("Rotate still pending for session %s", session->name); + ret = 1; + goto error; + } + if (ksess && ksess->consumer) { ret = consumer_is_data_pending(ksess->id, ksess->consumer); if (ret == 1) { @@ -2611,11 +3553,10 @@ int cmd_snapshot_add_output(struct ltt_session *session, DBG("Cmd snapshot add output for session %s", session->name); /* - * Permission denied to create an output if the session is not - * set in no output mode. + * Can't create an output if the session is not set in no-output mode. */ if (session->output_traces) { - ret = LTTNG_ERR_EPERM; + ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; goto error; } @@ -2679,7 +3620,7 @@ int cmd_snapshot_del_output(struct ltt_session *session, * set in no output mode. */ if (session->output_traces) { - ret = LTTNG_ERR_EPERM; + ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; goto error; } @@ -2717,7 +3658,7 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, struct lttng_snapshot_output **outputs) { int ret, idx = 0; - struct lttng_snapshot_output *list; + struct lttng_snapshot_output *list = NULL; struct lttng_ht_iter iter; struct snapshot_output *output; @@ -2731,282 +3672,616 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, * set in no output mode. */ if (session->output_traces) { - ret = LTTNG_ERR_EPERM; - goto error; + ret = -LTTNG_ERR_NOT_SNAPSHOT_SESSION; + goto end; } if (session->snapshot.nb_output == 0) { ret = 0; - goto error; + goto end; } list = zmalloc(session->snapshot.nb_output * sizeof(*list)); if (!list) { - ret = LTTNG_ERR_NOMEM; - goto error; + ret = -LTTNG_ERR_NOMEM; + goto end; } /* Copy list from session to the new list object. */ + rcu_read_lock(); cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter, output, node.node) { assert(output->consumer); list[idx].id = output->id; list[idx].max_size = output->max_size; - strncpy(list[idx].name, output->name, sizeof(list[idx].name)); + if (lttng_strncpy(list[idx].name, output->name, + sizeof(list[idx].name))) { + ret = -LTTNG_ERR_INVALID; + goto error; + } if (output->consumer->type == CONSUMER_DST_LOCAL) { - strncpy(list[idx].ctrl_url, output->consumer->dst.trace_path, - sizeof(list[idx].ctrl_url)); + if (lttng_strncpy(list[idx].ctrl_url, + output->consumer->dst.session_root_path, + sizeof(list[idx].ctrl_url))) { + ret = -LTTNG_ERR_INVALID; + goto error; + } } else { /* Control URI. */ ret = uri_to_str_url(&output->consumer->dst.net.control, list[idx].ctrl_url, sizeof(list[idx].ctrl_url)); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto free_error; + ret = -LTTNG_ERR_NOMEM; + goto error; } /* Data URI. */ ret = uri_to_str_url(&output->consumer->dst.net.data, list[idx].data_url, sizeof(list[idx].data_url)); if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto free_error; + ret = -LTTNG_ERR_NOMEM; + goto error; } } idx++; } *outputs = list; - return session->snapshot.nb_output; - -free_error: - free(list); + list = NULL; + ret = session->snapshot.nb_output; error: - return -ret; + rcu_read_unlock(); + free(list); +end: + return ret; } /* - * Send relayd sockets from snapshot output to consumer. Ignore request if the - * snapshot output is *not* set with a remote destination. + * Check if we can regenerate the metadata for this session. + * Only kernel, UST per-uid and non-live sessions are supported. * - * Return 0 on success or a LTTNG_ERR code. + * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise. */ -static int set_relayd_for_snapshot(struct consumer_output *consumer, - struct snapshot_output *snap_output, struct ltt_session *session) +static +int check_regenerate_metadata_support(struct ltt_session *session) { - int ret = LTTNG_OK; - struct lttng_ht_iter iter; - struct consumer_socket *socket; + int ret; - assert(consumer); - assert(snap_output); assert(session); - DBG2("Set relayd object from snapshot output"); + if (session->live_timer != 0) { + ret = LTTNG_ERR_LIVE_SESSION; + goto end; + } + if (!session->active) { + ret = LTTNG_ERR_SESSION_NOT_STARTED; + goto end; + } + if (session->ust_session) { + switch (session->ust_session->buffer_type) { + case LTTNG_BUFFER_PER_UID: + break; + case LTTNG_BUFFER_PER_PID: + ret = LTTNG_ERR_PER_PID_SESSION; + goto end; + default: + assert(0); + ret = LTTNG_ERR_UNK; + goto end; + } + } + if (session->consumer->type == CONSUMER_DST_NET && + session->consumer->relay_minor_version < 8) { + ret = LTTNG_ERR_RELAYD_VERSION_FAIL; + goto end; + } + ret = 0; - /* Ignore if snapshot consumer output is not network. */ - if (snap_output->consumer->type != CONSUMER_DST_NET) { - goto error; +end: + return ret; +} + +static +int clear_metadata_file(int fd) +{ + int ret; + off_t lseek_ret; + + lseek_ret = lseek(fd, 0, SEEK_SET); + if (lseek_ret < 0) { + PERROR("lseek"); + ret = -1; + goto end; } - /* - * For each consumer socket, create and send the relayd object of the - * snapshot output. - */ + ret = ftruncate(fd, 0); + if (ret < 0) { + PERROR("ftruncate"); + goto end; + } + +end: + return ret; +} + +static +int ust_regenerate_metadata(struct ltt_ust_session *usess) +{ + int ret = 0; + struct buffer_reg_uid *uid_reg = NULL; + struct buffer_reg_session *session_reg = NULL; + rcu_read_lock(); - cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, - socket, node.node) { - ret = send_consumer_relayd_sockets(0, session->id, - snap_output->consumer, socket, - session->name, session->hostname, - session->live_timer); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; + cds_list_for_each_entry(uid_reg, &usess->buffer_reg_uid_list, lnode) { + struct ust_registry_session *registry; + struct ust_registry_channel *chan; + struct lttng_ht_iter iter_chan; + + session_reg = uid_reg->registry; + registry = session_reg->reg.ust; + + pthread_mutex_lock(®istry->lock); + registry->metadata_len_sent = 0; + memset(registry->metadata, 0, registry->metadata_alloc_len); + registry->metadata_len = 0; + registry->metadata_version++; + if (registry->metadata_fd > 0) { + /* Clear the metadata file's content. */ + ret = clear_metadata_file(registry->metadata_fd); + if (ret) { + pthread_mutex_unlock(®istry->lock); + goto end; + } + } + + ret = ust_metadata_session_statedump(registry, NULL, + registry->major, registry->minor); + if (ret) { + pthread_mutex_unlock(®istry->lock); + ERR("Failed to generate session metadata (err = %d)", + ret); + goto end; + } + cds_lfht_for_each_entry(registry->channels->ht, &iter_chan.iter, + chan, node.node) { + struct ust_registry_event *event; + struct lttng_ht_iter iter_event; + + ret = ust_metadata_channel_statedump(registry, chan); + if (ret) { + pthread_mutex_unlock(®istry->lock); + ERR("Failed to generate channel metadata " + "(err = %d)", ret); + goto end; + } + cds_lfht_for_each_entry(chan->ht->ht, &iter_event.iter, + event, node.node) { + ret = ust_metadata_event_statedump(registry, + chan, event); + if (ret) { + pthread_mutex_unlock(®istry->lock); + ERR("Failed to generate event metadata " + "(err = %d)", ret); + goto end; + } + } } + pthread_mutex_unlock(®istry->lock); } - rcu_read_unlock(); -error: +end: + rcu_read_unlock(); return ret; } /* - * Record a kernel snapshot. + * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library. * - * Return LTTNG_OK on success or a LTTNG_ERR code. + * Ask the consumer to truncate the existing metadata file(s) and + * then regenerate the metadata. Live and per-pid sessions are not + * supported and return an error. + * + * Return 0 on success or else a LTTNG_ERR code. */ -static int record_kernel_snapshot(struct ltt_kernel_session *ksess, - struct snapshot_output *output, struct ltt_session *session, - int wait, uint64_t max_stream_size) +int cmd_regenerate_metadata(struct ltt_session *session) { int ret; - assert(ksess); - assert(output); assert(session); - /* Get the datetime for the snapshot output directory. */ - ret = utils_get_current_time_str("%Y%m%d-%H%M%S", output->datetime, - sizeof(output->datetime)); - if (!ret) { - ret = LTTNG_ERR_INVALID; - goto error; - } - - /* - * Copy kernel session sockets so we can communicate with the right - * consumer for the snapshot record command. - */ - ret = consumer_copy_sockets(output->consumer, ksess->consumer); - if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto error; + ret = check_regenerate_metadata_support(session); + if (ret) { + goto end; } - ret = set_relayd_for_snapshot(ksess->consumer, output, session); - if (ret != LTTNG_OK) { - goto error_snapshot; + if (session->kernel_session) { + ret = kernctl_session_regenerate_metadata( + session->kernel_session->fd); + if (ret < 0) { + ERR("Failed to regenerate the kernel metadata"); + goto end; + } } - ret = kernel_snapshot_record(ksess, output, wait, max_stream_size); - if (ret != LTTNG_OK) { - goto error_snapshot; + if (session->ust_session) { + ret = ust_regenerate_metadata(session->ust_session); + if (ret < 0) { + ERR("Failed to regenerate the UST metadata"); + goto end; + } } - + DBG("Cmd metadata regenerate for session %s", session->name); ret = LTTNG_OK; -error_snapshot: - /* Clean up copied sockets so this output can use some other later on. */ - consumer_destroy_output_sockets(output->consumer); -error: +end: return ret; } /* - * Record a UST snapshot. + * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library. + * + * Ask the tracer to regenerate a new statedump. * - * Return 0 on success or a LTTNG_ERR error code. + * Return 0 on success or else a LTTNG_ERR code. */ -static int record_ust_snapshot(struct ltt_ust_session *usess, - struct snapshot_output *output, struct ltt_session *session, - int wait, uint64_t max_stream_size) +int cmd_regenerate_statedump(struct ltt_session *session) { int ret; - assert(usess); - assert(output); assert(session); - /* Get the datetime for the snapshot output directory. */ - ret = utils_get_current_time_str("%Y%m%d-%H%M%S", output->datetime, - sizeof(output->datetime)); - if (!ret) { - ret = LTTNG_ERR_INVALID; - goto error; + if (!session->active) { + ret = LTTNG_ERR_SESSION_NOT_STARTED; + goto end; } - /* - * Copy UST session sockets so we can communicate with the right - * consumer for the snapshot record command. - */ - ret = consumer_copy_sockets(output->consumer, usess->consumer); - if (ret < 0) { - ret = LTTNG_ERR_NOMEM; - goto error; - } + if (session->kernel_session) { + ret = kernctl_session_regenerate_statedump( + session->kernel_session->fd); + /* + * Currently, the statedump in kernel can only fail if out + * of memory. + */ + if (ret < 0) { + if (ret == -ENOMEM) { + ret = LTTNG_ERR_REGEN_STATEDUMP_NOMEM; + } else { + ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL; + } + ERR("Failed to regenerate the kernel statedump"); + goto end; + } + } - ret = set_relayd_for_snapshot(usess->consumer, output, session); - if (ret != LTTNG_OK) { - goto error_snapshot; + if (session->ust_session) { + ret = ust_app_regenerate_statedump_all(session->ust_session); + /* + * Currently, the statedump in UST always returns 0. + */ + if (ret < 0) { + ret = LTTNG_ERR_REGEN_STATEDUMP_FAIL; + ERR("Failed to regenerate the UST statedump"); + goto end; + } } + DBG("Cmd regenerate statedump for session %s", session->name); + ret = LTTNG_OK; - ret = ust_app_snapshot_record(usess, output, wait, max_stream_size); - if (ret < 0) { - switch (-ret) { - case EINVAL: - ret = LTTNG_ERR_INVALID; - break; - case ENODATA: - ret = LTTNG_ERR_SNAPSHOT_NODATA; - break; - default: - ret = LTTNG_ERR_SNAPSHOT_FAIL; - break; +end: + return ret; +} + +int cmd_register_trigger(struct command_ctx *cmd_ctx, int sock, + struct notification_thread_handle *notification_thread) +{ + int ret; + size_t trigger_len; + ssize_t sock_recv_len; + struct lttng_trigger *trigger = NULL; + struct lttng_buffer_view view; + struct lttng_dynamic_buffer trigger_buffer; + + lttng_dynamic_buffer_init(&trigger_buffer); + trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; + ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto end; + } + + sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data, + trigger_len); + if (sock_recv_len < 0 || sock_recv_len != trigger_len) { + ERR("Failed to receive \"register trigger\" command payload"); + /* TODO: should this be a new error enum ? */ + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + + view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1); + if (lttng_trigger_create_from_buffer(&view, &trigger) != + trigger_len) { + ERR("Invalid trigger payload received in \"register trigger\" command"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + + ret = notification_thread_command_register_trigger(notification_thread, + trigger); + /* Ownership of trigger was transferred. */ + trigger = NULL; +end: + lttng_trigger_destroy(trigger); + lttng_dynamic_buffer_reset(&trigger_buffer); + return ret; +} + +int cmd_unregister_trigger(struct command_ctx *cmd_ctx, int sock, + struct notification_thread_handle *notification_thread) +{ + int ret; + size_t trigger_len; + ssize_t sock_recv_len; + struct lttng_trigger *trigger = NULL; + struct lttng_buffer_view view; + struct lttng_dynamic_buffer trigger_buffer; + + lttng_dynamic_buffer_init(&trigger_buffer); + trigger_len = (size_t) cmd_ctx->lsm->u.trigger.length; + ret = lttng_dynamic_buffer_set_size(&trigger_buffer, trigger_len); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto end; + } + + sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_buffer.data, + trigger_len); + if (sock_recv_len < 0 || sock_recv_len != trigger_len) { + ERR("Failed to receive \"unregister trigger\" command payload"); + /* TODO: should this be a new error enum ? */ + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + + view = lttng_buffer_view_from_dynamic_buffer(&trigger_buffer, 0, -1); + if (lttng_trigger_create_from_buffer(&view, &trigger) != + trigger_len) { + ERR("Invalid trigger payload received in \"unregister trigger\" command"); + ret = LTTNG_ERR_INVALID_TRIGGER; + goto end; + } + + ret = notification_thread_command_unregister_trigger(notification_thread, + trigger); +end: + lttng_trigger_destroy(trigger); + lttng_dynamic_buffer_reset(&trigger_buffer); + return ret; +} + +/* + * Send relayd sockets from snapshot output to consumer. Ignore request if the + * snapshot output is *not* set with a remote destination. + * + * Return LTTNG_OK on success or a LTTNG_ERR code. + */ +static enum lttng_error_code set_relayd_for_snapshot( + struct consumer_output *consumer, + struct snapshot_output *snap_output, + struct ltt_session *session) +{ + enum lttng_error_code status = LTTNG_OK; + struct lttng_ht_iter iter; + struct consumer_socket *socket; + + assert(consumer); + assert(snap_output); + assert(session); + + DBG2("Set relayd object from snapshot output"); + + /* Ignore if snapshot consumer output is not network. */ + if (snap_output->consumer->type != CONSUMER_DST_NET) { + goto error; + } + + /* + * For each consumer socket, create and send the relayd object of the + * snapshot output. + */ + rcu_read_lock(); + cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, + socket, node.node) { + pthread_mutex_lock(socket->lock); + status = send_consumer_relayd_sockets(0, session->id, + snap_output->consumer, socket, + session->name, session->hostname, + session->live_timer); + pthread_mutex_unlock(socket->lock); + if (status != LTTNG_OK) { + rcu_read_unlock(); + goto error; } + } + rcu_read_unlock(); + +error: + return status; +} + +/* + * Record a kernel snapshot. + * + * Return LTTNG_OK on success or a LTTNG_ERR code. + */ +static enum lttng_error_code record_kernel_snapshot(struct ltt_kernel_session *ksess, + struct snapshot_output *output, struct ltt_session *session, + int wait, uint64_t nb_packets_per_stream) +{ + int ret; + enum lttng_error_code status; + + assert(ksess); + assert(output); + assert(session); + + /* + * Copy kernel session sockets so we can communicate with the right + * consumer for the snapshot record command. + */ + ret = consumer_copy_sockets(output->consumer, ksess->consumer); + if (ret < 0) { + status = LTTNG_ERR_NOMEM; + goto error; + } + + status = set_relayd_for_snapshot(ksess->consumer, output, session); + if (status != LTTNG_OK) { goto error_snapshot; } - ret = LTTNG_OK; + status = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream); + if (status != LTTNG_OK) { + goto error_snapshot; + } + + goto end; error_snapshot: /* Clean up copied sockets so this output can use some other later on. */ consumer_destroy_output_sockets(output->consumer); error: - return ret; +end: + return status; } /* - * Return the biggest subbuffer size of all channels in the given session. + * Record a UST snapshot. + * + * Returns LTTNG_OK on success or a LTTNG_ERR error code. */ -static uint64_t get_session_max_subbuf_size(struct ltt_session *session) +static enum lttng_error_code record_ust_snapshot(struct ltt_ust_session *usess, + struct snapshot_output *output, struct ltt_session *session, + int wait, uint64_t nb_packets_per_stream) { - uint64_t max_size = 0; + int ret; + enum lttng_error_code status; + assert(usess); + assert(output); assert(session); + /* + * Copy UST session sockets so we can communicate with the right + * consumer for the snapshot record command. + */ + ret = consumer_copy_sockets(output->consumer, usess->consumer); + if (ret < 0) { + status = LTTNG_ERR_NOMEM; + goto error; + } + + status = set_relayd_for_snapshot(usess->consumer, output, session); + if (status != LTTNG_OK) { + goto error_snapshot; + } + + status = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream); + if (status != LTTNG_OK) { + goto error_snapshot; + } + +error_snapshot: + /* Clean up copied sockets so this output can use some other later on. */ + consumer_destroy_output_sockets(output->consumer); +error: + return status; +} + +static +uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session, + uint64_t cur_nr_packets) +{ + uint64_t tot_size = 0; + if (session->kernel_session) { struct ltt_kernel_channel *chan; struct ltt_kernel_session *ksess = session->kernel_session; - /* - * For each channel, add to the max size the size of each subbuffer - * multiplied by their sized. - */ cds_list_for_each_entry(chan, &ksess->channel_list.head, list) { - if (chan->channel->attr.subbuf_size > max_size) { - max_size = chan->channel->attr.subbuf_size; + if (cur_nr_packets >= chan->channel->attr.num_subbuf) { + /* + * Don't take channel into account if we + * already grab all its packets. + */ + continue; } + tot_size += chan->channel->attr.subbuf_size + * chan->stream_count; } } if (session->ust_session) { - struct lttng_ht_iter iter; - struct ltt_ust_channel *uchan; struct ltt_ust_session *usess = session->ust_session; - cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter, - uchan, node.node) { - if (uchan->attr.subbuf_size > max_size) { - max_size = uchan->attr.subbuf_size; - } - } + tot_size += ust_app_get_size_one_more_packet_per_stream(usess, + cur_nr_packets); } - return max_size; + return tot_size; } /* - * Returns the total number of streams for a session or a negative value - * on error. + * Calculate the number of packets we can grab from each stream that + * fits within the overall snapshot max size. + * + * Returns -1 on error, 0 means infinite number of packets, else > 0 is + * the number of packets per stream. + * + * TODO: this approach is not perfect: we consider the worse case + * (packet filling the sub-buffers) as an upper bound, but we could do + * better if we do this calculation while we actually grab the packet + * content: we would know how much padding we don't actually store into + * the file. + * + * This algorithm is currently bounded by the number of packets per + * stream. + * + * Since we call this algorithm before actually grabbing the data, it's + * an approximation: for instance, applications could appear/disappear + * in between this call and actually grabbing data. */ -static unsigned int get_session_nb_streams(struct ltt_session *session) +static +int64_t get_session_nb_packets_per_stream(struct ltt_session *session, uint64_t max_size) { - unsigned int total_streams = 0; - - if (session->kernel_session) { - struct ltt_kernel_session *ksess = session->kernel_session; + int64_t size_left; + uint64_t cur_nb_packets = 0; - total_streams += ksess->stream_count_global; + if (!max_size) { + return 0; /* Infinite */ } - if (session->ust_session) { - struct ltt_ust_session *usess = session->ust_session; + size_left = max_size; + for (;;) { + uint64_t one_more_packet_tot_size; - total_streams += ust_app_get_nb_stream(usess); + one_more_packet_tot_size = get_session_size_one_more_packet_per_stream(session, + cur_nb_packets); + if (!one_more_packet_tot_size) { + /* We are already grabbing all packets. */ + break; + } + size_left -= one_more_packet_tot_size; + if (size_left < 0) { + break; + } + cur_nb_packets++; } - - return total_streams; + if (!cur_nb_packets) { + /* Not enough room to grab one packet of each stream, error. */ + return -1; + } + return cur_nb_packets; } /* @@ -3020,201 +4295,735 @@ static unsigned int get_session_nb_streams(struct ltt_session *session) int cmd_snapshot_record(struct ltt_session *session, struct lttng_snapshot_output *output, int wait) { - int ret = LTTNG_OK; + enum lttng_error_code cmd_ret = LTTNG_OK; + int ret; unsigned int use_tmp_output = 0; struct snapshot_output tmp_output; - unsigned int nb_streams, snapshot_success = 0; - uint64_t session_max_size = 0, max_stream_size = 0; + unsigned int snapshot_success = 0; + char datetime[16]; assert(session); + assert(output); DBG("Cmd snapshot record for session %s", session->name); + /* Get the datetime for the snapshot output directory. */ + ret = utils_get_current_time_str("%Y%m%d-%H%M%S", datetime, + sizeof(datetime)); + if (!ret) { + cmd_ret = LTTNG_ERR_INVALID; + goto error; + } + /* * Permission denied to create an output if the session is not * set in no output mode. */ if (session->output_traces) { - ret = LTTNG_ERR_EPERM; + cmd_ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; goto error; } /* The session needs to be started at least once. */ if (!session->has_been_started) { - ret = LTTNG_ERR_START_SESSION_ONCE; + cmd_ret = LTTNG_ERR_START_SESSION_ONCE; goto error; } /* Use temporary output for the session. */ - if (output && *output->ctrl_url != '\0') { + if (*output->ctrl_url != '\0') { ret = snapshot_output_init(output->max_size, output->name, output->ctrl_url, output->data_url, session->consumer, &tmp_output, NULL); if (ret < 0) { if (ret == -ENOMEM) { - ret = LTTNG_ERR_NOMEM; + cmd_ret = LTTNG_ERR_NOMEM; } else { - ret = LTTNG_ERR_INVALID; + cmd_ret = LTTNG_ERR_INVALID; } goto error; } /* Use the global session count for the temporary snapshot. */ tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + + /* Use the global datetime */ + memcpy(tmp_output.datetime, datetime, sizeof(datetime)); use_tmp_output = 1; } + if (use_tmp_output) { + int64_t nb_packets_per_stream; + + nb_packets_per_stream = get_session_nb_packets_per_stream(session, + tmp_output.max_size); + if (nb_packets_per_stream < 0) { + cmd_ret = LTTNG_ERR_MAX_SIZE_INVALID; + goto error; + } + + if (session->kernel_session) { + cmd_ret = record_kernel_snapshot(session->kernel_session, + &tmp_output, session, + wait, nb_packets_per_stream); + if (cmd_ret != LTTNG_OK) { + goto error; + } + } + + if (session->ust_session) { + cmd_ret = record_ust_snapshot(session->ust_session, + &tmp_output, session, + wait, nb_packets_per_stream); + if (cmd_ret != LTTNG_OK) { + goto error; + } + } + + snapshot_success = 1; + } else { + struct snapshot_output *sout; + struct lttng_ht_iter iter; + + rcu_read_lock(); + cds_lfht_for_each_entry(session->snapshot.output_ht->ht, + &iter.iter, sout, node.node) { + int64_t nb_packets_per_stream; + + /* + * Make a local copy of the output and assign the possible + * temporary value given by the caller. + */ + memset(&tmp_output, 0, sizeof(tmp_output)); + memcpy(&tmp_output, sout, sizeof(tmp_output)); + + if (output->max_size != (uint64_t) -1ULL) { + tmp_output.max_size = output->max_size; + } + + nb_packets_per_stream = get_session_nb_packets_per_stream(session, + tmp_output.max_size); + if (nb_packets_per_stream < 0) { + cmd_ret = LTTNG_ERR_MAX_SIZE_INVALID; + rcu_read_unlock(); + goto error; + } + + /* Use temporary name. */ + if (*output->name != '\0') { + if (lttng_strncpy(tmp_output.name, output->name, + sizeof(tmp_output.name))) { + cmd_ret = LTTNG_ERR_INVALID; + rcu_read_unlock(); + goto error; + } + } + + tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + memcpy(tmp_output.datetime, datetime, sizeof(datetime)); + + if (session->kernel_session) { + cmd_ret = record_kernel_snapshot(session->kernel_session, + &tmp_output, session, + wait, nb_packets_per_stream); + if (cmd_ret != LTTNG_OK) { + rcu_read_unlock(); + goto error; + } + } + + if (session->ust_session) { + cmd_ret = record_ust_snapshot(session->ust_session, + &tmp_output, session, + wait, nb_packets_per_stream); + if (cmd_ret != LTTNG_OK) { + rcu_read_unlock(); + goto error; + } + } + snapshot_success = 1; + } + rcu_read_unlock(); + } + + if (snapshot_success) { + session->snapshot.nb_snapshot++; + } else { + cmd_ret = LTTNG_ERR_SNAPSHOT_FAIL; + } + +error: + return cmd_ret; +} + +/* + * Command LTTNG_SET_SESSION_SHM_PATH processed by the client thread. + */ +int cmd_set_session_shm_path(struct ltt_session *session, + const char *shm_path) +{ + /* Safety net */ + assert(session); + + /* + * Can only set shm path before session is started. + */ + if (session->has_been_started) { + return LTTNG_ERR_SESSION_STARTED; + } + + strncpy(session->shm_path, shm_path, + sizeof(session->shm_path)); + session->shm_path[sizeof(session->shm_path) - 1] = '\0'; + + return 0; +} + +/* + * Command LTTNG_ROTATE_SESSION from the lttng-ctl library. + * + * Ask the consumer to rotate the session output directory. + * The session lock must be held. + * + * Returns LTTNG_OK on success or else a negative LTTng error code. + */ +int cmd_rotate_session(struct ltt_session *session, + struct lttng_rotate_session_return *rotate_return) +{ + int ret; + enum lttng_error_code cmd_ret = LTTNG_OK; + size_t strf_ret; + struct tm *timeinfo; + char datetime[21]; + time_t now; + /* + * Used to roll-back timestamps in case of failure to launch the + * rotation. + */ + time_t original_last_chunk_start_ts, original_current_chunk_start_ts; + + assert(session); + + if (!session->has_been_started) { + cmd_ret = LTTNG_ERR_START_SESSION_ONCE; + goto end; + } + + if (session->live_timer || session->snapshot_mode || + !session->output_traces) { + cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE; + goto end; + } + + /* + * Unsupported feature in lttng-relayd before 2.11. + */ + if (session->consumer->type == CONSUMER_DST_NET && + (session->consumer->relay_major_version == 2 && + session->consumer->relay_minor_version < 11)) { + cmd_ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY; + goto end; + } + + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING) { + DBG("Refusing to launch a rotation; a rotation is already in progress for session %s", + session->name); + cmd_ret = LTTNG_ERR_ROTATION_PENDING; + goto end; + } + /* - * Get the session maximum size for a snapshot meaning it will compute the - * size of all streams from all domain. + * After a stop, we only allow one rotation to occur, the other ones are + * useless until a new start. */ - max_stream_size = get_session_max_subbuf_size(session); + if (session->rotated_after_last_stop) { + DBG("Session \"%s\" was already rotated after stop, refusing rotation", + session->name); + cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP; + goto end; + } + + /* Special case for the first rotation. */ + if (session->current_archive_id == 0) { + const char *base_path = NULL; + + assert(session->kernel_session || session->ust_session); + /* Either one of the two sessions is enough to get the root path. */ + base_path = session_get_base_path(session); + assert(base_path); - nb_streams = get_session_nb_streams(session); - if (nb_streams) { + ret = lttng_strncpy(session->rotation_chunk.current_rotate_path, + base_path, + sizeof(session->rotation_chunk.current_rotate_path)); + if (ret) { + ERR("Failed to copy session base path to current rotation chunk path"); + cmd_ret = LTTNG_ERR_UNK; + goto end; + } + } else { /* - * The maximum size of the snapshot is the number of streams multiplied - * by the biggest subbuf size of all channels in a session which is the - * maximum stream size available for each stream. The session max size - * is now checked against the snapshot max size value given by the user - * and if lower, an error is returned. + * The currently active tracing path is now the folder we + * want to rotate. */ - session_max_size = max_stream_size * nb_streams; + ret = lttng_strncpy(session->rotation_chunk.current_rotate_path, + session->rotation_chunk.active_tracing_path, + sizeof(session->rotation_chunk.current_rotate_path)); + if (ret) { + ERR("Failed to copy the active tracing path to the current rotate path"); + cmd_ret = LTTNG_ERR_UNK; + goto end; + } + } + DBG("Current rotate path %s", session->rotation_chunk.current_rotate_path); + + /* + * Channels created after this point will belong to the next + * archive id. + */ + session->current_archive_id++; + + now = time(NULL); + if (now == (time_t) -1) { + cmd_ret = LTTNG_ERR_UNK; + goto end; } - DBG3("Snapshot max size is %" PRIu64 " for max stream size of %" PRIu64, - session_max_size, max_stream_size); + /* Sample chunk bounds for roll-back in case of error. */ + original_last_chunk_start_ts = session->last_chunk_start_ts; + original_current_chunk_start_ts = session->current_chunk_start_ts; + + session->last_chunk_start_ts = session->current_chunk_start_ts; + session->current_chunk_start_ts = now; + + timeinfo = localtime(&now); + if (!timeinfo) { + PERROR("Failed to sample local time in rotate session command"); + cmd_ret = LTTNG_ERR_UNK; + goto end; + } + strf_ret = strftime(datetime, sizeof(datetime), "%Y%m%dT%H%M%S%z", + timeinfo); + if (!strf_ret) { + ERR("Failed to format local time timestamp in rotate session command"); + cmd_ret = LTTNG_ERR_UNK; + goto end; + } /* - * If we use a temporary output, check right away if the max size fits else - * for each output the max size will be checked. + * A rotation has a local step even if the destination is a relay + * daemon; the buffers must be consumed by the consumer daemon. */ - if (use_tmp_output && - (tmp_output.max_size != 0 && - tmp_output.max_size < session_max_size)) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; + session->rotation_pending_local = true; + session->rotation_pending_relay = + session_get_consumer_destination_type(session) == CONSUMER_DST_NET; + session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + + if (session->kernel_session) { + /* + * The active path for the next rotation/destroy. + * Ex: ~/lttng-traces/auto-20170922-111748/20170922-111754-42 + */ + ret = snprintf(session->rotation_chunk.active_tracing_path, + sizeof(session->rotation_chunk.active_tracing_path), + "%s/%s-%" PRIu64, + session_get_base_path(session), + datetime, session->current_archive_id + 1); + if (ret < 0 || ret == sizeof(session->rotation_chunk.active_tracing_path)) { + ERR("Failed to format active kernel tracing path in rotate session command"); + cmd_ret = LTTNG_ERR_UNK; + goto error; + } + /* + * The sub-directory for the consumer + * Ex: /20170922-111754-42/kernel + */ + ret = snprintf(session->kernel_session->consumer->chunk_path, + sizeof(session->kernel_session->consumer->chunk_path), + "/%s-%" PRIu64, datetime, + session->current_archive_id + 1); + if (ret < 0 || ret == sizeof(session->kernel_session->consumer->chunk_path)) { + ERR("Failed to format the kernel consumer's sub-directory in rotate session command"); + cmd_ret = LTTNG_ERR_UNK; + goto error; + } + /* + * Create the new chunk folder, before the rotation begins so we don't + * race with the consumer/tracer activity. + */ + ret = domain_mkdir(session->kernel_session->consumer, session, + session->kernel_session->uid, + session->kernel_session->gid); + if (ret) { + ERR("Failed to create kernel session tracing path at %s", + session->kernel_session->consumer->chunk_path); + cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + cmd_ret = kernel_rotate_session(session); + if (cmd_ret != LTTNG_OK) { + goto error; + } + } + if (session->ust_session) { + ret = snprintf(session->rotation_chunk.active_tracing_path, + PATH_MAX, "%s/%s-%" PRIu64, + session_get_base_path(session), + datetime, session->current_archive_id + 1); + if (ret < 0) { + ERR("Failed to format active UST tracing path in rotate session command"); + cmd_ret = LTTNG_ERR_UNK; + goto error; + } + ret = snprintf(session->ust_session->consumer->chunk_path, + PATH_MAX, "/%s-%" PRIu64, datetime, + session->current_archive_id + 1); + if (ret < 0) { + ERR("Failed to format the UST consumer's sub-directory in rotate session command"); + cmd_ret = LTTNG_ERR_UNK; + goto error; + } + /* + * Create the new chunk folder, before the rotation begins so we don't + * race with the consumer/tracer activity. + */ + ret = domain_mkdir(session->ust_session->consumer, session, + session->ust_session->uid, + session->ust_session->gid); + if (ret) { + cmd_ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + cmd_ret = ust_app_rotate_session(session); + if (cmd_ret != LTTNG_OK) { + goto error; + } + } + + ret = timer_session_rotation_pending_check_start(session, + DEFAULT_ROTATE_PENDING_TIMER); + if (ret) { + cmd_ret = LTTNG_ERR_UNK; goto error; } - if (session->kernel_session) { - struct ltt_kernel_session *ksess = session->kernel_session; + if (!session->active) { + session->rotated_after_last_stop = true; + } - if (use_tmp_output) { - ret = record_kernel_snapshot(ksess, &tmp_output, session, - wait, max_stream_size); - if (ret != LTTNG_OK) { - goto error; - } - snapshot_success = 1; - } else { - struct snapshot_output *sout; - struct lttng_ht_iter iter; + if (rotate_return) { + rotate_return->rotation_id = session->current_archive_id; + } - rcu_read_lock(); - cds_lfht_for_each_entry(session->snapshot.output_ht->ht, - &iter.iter, sout, node.node) { - /* - * Make a local copy of the output and assign the possible - * temporary value given by the caller. - */ - memset(&tmp_output, 0, sizeof(tmp_output)); - memcpy(&tmp_output, sout, sizeof(tmp_output)); + ret = notification_thread_command_session_rotation_ongoing( + notification_thread_handle, + session->name, session->uid, session->gid, + session->current_archive_id - 1); + if (ret != LTTNG_OK) { + ERR("Failed to notify notification thread that a session rotation is ongoing for session %s", + session->name); + cmd_ret = ret; + } - /* Use temporary max size. */ - if (output->max_size != (uint64_t) -1ULL) { - tmp_output.max_size = output->max_size; - } + DBG("Cmd rotate session %s, archive_id %" PRIu64 " sent", + session->name, session->current_archive_id - 1); +end: + ret = (cmd_ret == LTTNG_OK) ? cmd_ret : -((int) cmd_ret); + return ret; +error: + session->last_chunk_start_ts = original_last_chunk_start_ts; + session->current_archive_id = original_current_chunk_start_ts; + if (session_reset_rotation_state(session, + LTTNG_ROTATION_STATE_NO_ROTATION)) { + ERR("Failed to reset rotation state of session \"%s\"", + session->name); + } + goto end; +} - if (tmp_output.max_size != 0 && - tmp_output.max_size < session_max_size) { - rcu_read_unlock(); - ret = LTTNG_ERR_MAX_SIZE_INVALID; - goto error; - } +/* + * Command LTTNG_ROTATION_GET_INFO from the lttng-ctl library. + * + * Check if the session has finished its rotation. + * + * Return 0 on success or else a LTTNG_ERR code. + */ +int cmd_rotate_get_info(struct ltt_session *session, + struct lttng_rotation_get_info_return *info_return, + uint64_t rotation_id) +{ + int ret; - /* Use temporary name. */ - if (*output->name != '\0') { - strncpy(tmp_output.name, output->name, - sizeof(tmp_output.name)); - } + assert(session); - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name, + session->current_archive_id); - ret = record_kernel_snapshot(ksess, &tmp_output, - session, wait, max_stream_size); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; - } - snapshot_success = 1; + if (session->current_archive_id != rotation_id) { + info_return->status = (int32_t) LTTNG_ROTATION_STATE_EXPIRED; + ret = LTTNG_OK; + goto end; + } + + switch (session->rotation_state) { + case LTTNG_ROTATION_STATE_ONGOING: + DBG("Reporting that rotation id %" PRIu64 " of session %s is still pending", + rotation_id, session->name); + break; + case LTTNG_ROTATION_STATE_COMPLETED: + { + char *current_tracing_path_reply; + size_t current_tracing_path_reply_len; + + switch (session_get_consumer_destination_type(session)) { + case CONSUMER_DST_LOCAL: + current_tracing_path_reply = + info_return->location.local.absolute_path; + current_tracing_path_reply_len = + sizeof(info_return->location.local.absolute_path); + info_return->location_type = + (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL; + break; + case CONSUMER_DST_NET: + current_tracing_path_reply = + info_return->location.relay.relative_path; + current_tracing_path_reply_len = + sizeof(info_return->location.relay.relative_path); + /* Currently the only supported relay protocol. */ + info_return->location.relay.protocol = + (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_RELAY_PROTOCOL_TYPE_TCP; + + ret = lttng_strncpy(info_return->location.relay.host, + session_get_net_consumer_hostname(session), + sizeof(info_return->location.relay.host)); + if (ret) { + ERR("Failed to host name to rotate_get_info reply"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + ret = -LTTNG_ERR_UNK; + goto end; } - rcu_read_unlock(); + + session_get_net_consumer_ports(session, + &info_return->location.relay.ports.control, + &info_return->location.relay.ports.data); + info_return->location_type = + (int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY; + break; + default: + abort(); + } + ret = lttng_strncpy(current_tracing_path_reply, + session->rotation_chunk.current_rotate_path, + current_tracing_path_reply_len); + if (ret) { + ERR("Failed to copy current tracing path to rotate_get_info reply"); + info_return->status = LTTNG_ROTATION_STATUS_ERROR; + ret = -LTTNG_ERR_UNK; + goto end; } + + break; + } + case LTTNG_ROTATION_STATE_ERROR: + DBG("Reporting that an error occurred during rotation %" PRIu64 " of session %s", + rotation_id, session->name); + break; + default: + abort(); } - if (session->ust_session) { - struct ltt_ust_session *usess = session->ust_session; + info_return->status = (int32_t) session->rotation_state; + ret = LTTNG_OK; +end: + return ret; +} - if (use_tmp_output) { - ret = record_ust_snapshot(usess, &tmp_output, session, - wait, max_stream_size); - if (ret != LTTNG_OK) { - goto error; +/* + * Command LTTNG_ROTATION_SET_SCHEDULE from the lttng-ctl library. + * + * Configure the automatic rotation parameters. + * 'activate' to true means activate the rotation schedule type with 'new_value'. + * 'activate' to false means deactivate the rotation schedule and validate that + * 'new_value' has the same value as the currently active value. + * + * Return 0 on success or else a positive LTTNG_ERR code. + */ +int cmd_rotation_set_schedule(struct ltt_session *session, + bool activate, enum lttng_rotation_schedule_type schedule_type, + uint64_t new_value, + struct notification_thread_handle *notification_thread_handle) +{ + int ret; + uint64_t *parameter_value; + + assert(session); + + DBG("Cmd rotate set schedule session %s", session->name); + + if (session->live_timer || session->snapshot_mode || + !session->output_traces) { + DBG("Failing ROTATION_SET_SCHEDULE command as the rotation feature is not available for this session"); + ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE; + goto end; + } + + switch (schedule_type) { + case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: + parameter_value = &session->rotate_size; + break; + case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: + parameter_value = &session->rotate_timer_period; + if (new_value >= UINT_MAX) { + DBG("Failing ROTATION_SET_SCHEDULE command as the value requested for a periodic rotation schedule is invalid: %" PRIu64 " > %u (UINT_MAX)", + new_value, UINT_MAX); + ret = LTTNG_ERR_INVALID; + goto end; + } + break; + default: + WARN("Failing ROTATION_SET_SCHEDULE command on unknown schedule type"); + ret = LTTNG_ERR_INVALID; + goto end; + } + + /* Improper use of the API. */ + if (new_value == -1ULL) { + WARN("Failing ROTATION_SET_SCHEDULE command as the value requested is -1"); + ret = LTTNG_ERR_INVALID; + goto end; + } + + /* + * As indicated in struct ltt_session's comments, a value of == 0 means + * this schedule rotation type is not in use. + * + * Reject the command if we were asked to activate a schedule that was + * already active. + */ + if (activate && *parameter_value != 0) { + DBG("Failing ROTATION_SET_SCHEDULE (activate) command as the schedule is already active"); + ret = LTTNG_ERR_ROTATION_SCHEDULE_SET; + goto end; + } + + /* + * Reject the command if we were asked to deactivate a schedule that was + * not active. + */ + if (!activate && *parameter_value == 0) { + DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as the schedule is already inactive"); + ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET; + goto end; + } + + /* + * Reject the command if we were asked to deactivate a schedule that + * doesn't exist. + */ + if (!activate && *parameter_value != new_value) { + DBG("Failing ROTATION_SET_SCHEDULE (deactivate) command as an inexistant schedule was provided"); + ret = LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET; + goto end; + } + + *parameter_value = activate ? new_value : 0; + + switch (schedule_type) { + case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: + if (activate && session->active) { + /* + * Only start the timer if the session is active, + * otherwise it will be started when the session starts. + */ + ret = timer_session_rotation_schedule_timer_start( + session, new_value); + if (ret) { + ERR("Failed to enable session rotation timer in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; } - snapshot_success = 1; } else { - struct snapshot_output *sout; - struct lttng_ht_iter iter; + ret = timer_session_rotation_schedule_timer_stop( + session); + if (ret) { + ERR("Failed to disable session rotation timer in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } + } + break; + case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: + if (activate) { + ret = subscribe_session_consumed_size_rotation(session, + new_value, notification_thread_handle); + if (ret) { + ERR("Failed to enable consumed-size notification in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } + } else { + ret = unsubscribe_session_consumed_size_rotation(session, + notification_thread_handle); + if (ret) { + ERR("Failed to disable consumed-size notification in ROTATION_SET_SCHEDULE command"); + ret = LTTNG_ERR_UNK; + goto end; + } - rcu_read_lock(); - cds_lfht_for_each_entry(session->snapshot.output_ht->ht, - &iter.iter, sout, node.node) { - /* - * Make a local copy of the output and assign the possible - * temporary value given by the caller. - */ - memset(&tmp_output, 0, sizeof(tmp_output)); - memcpy(&tmp_output, sout, sizeof(tmp_output)); + } + break; + default: + /* Would have been caught before. */ + abort(); + } - /* Use temporary max size. */ - if (output->max_size != (uint64_t) -1ULL) { - tmp_output.max_size = output->max_size; - } + ret = LTTNG_OK; - if (tmp_output.max_size != 0 && - tmp_output.max_size < session_max_size) { - rcu_read_unlock(); - ret = LTTNG_ERR_MAX_SIZE_INVALID; - goto error; - } + goto end; - /* Use temporary name. */ - if (*output->name != '\0') { - strncpy(tmp_output.name, output->name, - sizeof(tmp_output.name)); - } +end: + return ret; +} - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; +/* Wait for a given path to be removed before continuing. */ +static enum lttng_error_code wait_on_path(void *path_data) +{ + const char *shm_path = path_data; - ret = record_ust_snapshot(usess, &tmp_output, session, - wait, max_stream_size); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; - } - snapshot_success = 1; + DBG("Waiting for the shm path at %s to be removed before completing session destruction", + shm_path); + while (true) { + int ret; + struct stat st; + + ret = stat(shm_path, &st); + if (ret) { + if (errno != ENOENT) { + PERROR("stat() returned an error while checking for the existence of the shm path"); + } else { + DBG("shm path no longer exists, completing the destruction of session"); + } + break; + } else { + if (!S_ISDIR(st.st_mode)) { + ERR("The type of shm path %s returned by stat() is not a directory; aborting the wait for shm path removal", + shm_path); + break; } - rcu_read_unlock(); } + usleep(SESSION_DESTROY_SHM_PATH_CHECK_DELAY_US); } + return LTTNG_OK; +} - if (snapshot_success) { - session->snapshot.nb_snapshot++; - } else { - ret = LTTNG_ERR_SNAPSHOT_FAIL; - } +/* + * Returns a pointer to a handler to run on completion of a command. + * Returns NULL if no handler has to be run for the last command executed. + */ +const struct cmd_completion_handler *cmd_pop_completion_handler(void) +{ + struct cmd_completion_handler *handler = current_completion_handler; -error: - return ret; + current_completion_handler = NULL; + return handler; } /*