X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=6722341bb4b1be79f11a88b96c8989a3cf15e734;hp=1ee0c98f99dadc3516714409aa20164f44f552ff;hb=462ae7ae036d5f0b4be820345f324e77f5b607c1;hpb=b31610f2294a6a827fa2d0d19d71199567db8dc5 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 1ee0c98f9..6722341bb 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -28,6 +28,16 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "channel.h" #include "consumer.h" @@ -37,8 +47,15 @@ #include "kernel-consumer.h" #include "lttng-sessiond.h" #include "utils.h" -#include "syscall.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 "sessiond-timer.h" +#include "agent-thread.h" #include "cmd.h" @@ -51,7 +68,6 @@ static pthread_mutex_t relayd_net_seq_idx_lock = PTHREAD_MUTEX_INITIALIZER; static uint64_t relayd_net_seq_idx; -static int validate_event_name(const char *); static int validate_ust_event_name(const char *); static int cmd_enable_event_internal(struct ltt_session *session, struct lttng_domain *domain, @@ -156,14 +172,14 @@ static int get_kernel_runtime_stats(struct ltt_session *session, goto end; } - ret = consumer_get_discarded_events(session->id, kchan->fd, + 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->fd, + ret = consumer_get_lost_packets(session->id, kchan->key, session->kernel_session->consumer, lost_packets); if (ret < 0) { @@ -185,7 +201,14 @@ static int get_ust_runtime_stats(struct ltt_session *session, 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; @@ -214,6 +237,7 @@ static int get_ust_runtime_stats(struct ltt_session *session, *lost_packets += uchan->per_pid_closed_app_lost; } else { ERR("Unsupported buffer type"); + assert(0); ret = -1; goto end; } @@ -225,11 +249,11 @@ end: /* * Fill lttng_channel array of all channels. */ -static void list_lttng_channels(enum lttng_domain_type domain, +static ssize_t list_lttng_channels(enum lttng_domain_type domain, struct ltt_session *session, struct lttng_channel *channels, - struct lttcomm_channel_extended *chan_exts) + struct lttng_channel_extended *chan_exts) { - int i = 0, ret; + int i = 0, ret = 0; struct ltt_kernel_channel *kchan; DBG("Listing channels for session %s", session->name); @@ -241,6 +265,10 @@ static void list_lttng_channels(enum lttng_domain_type domain, 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); @@ -253,6 +281,9 @@ static void list_lttng_channels(enum lttng_domain_type domain, 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++; } } @@ -265,9 +296,12 @@ static void list_lttng_channels(enum lttng_domain_type domain, rcu_read_lock(); cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht, &iter.iter, uchan, node.node) { - uint64_t discarded_events, lost_packets; + uint64_t discarded_events = 0, lost_packets = 0; - strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN); + 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; @@ -295,6 +329,11 @@ static void list_lttng_channels(enum lttng_domain_type domain, 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) { @@ -312,7 +351,11 @@ static void list_lttng_channels(enum lttng_domain_type domain, } end: - return; + if (ret < 0) { + return -LTTNG_ERR_FATAL; + } else { + return LTTNG_OK; + } } static void increment_extended_len(const char *filter_expression, @@ -746,14 +789,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; @@ -836,8 +882,11 @@ 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) { + goto close_sock; + } else if (ret < 0) { + ERR("Unable to reach lttng-relayd"); + ret = LTTNG_ERR_RELAYD_CONNECT_FAIL; goto close_sock; } consumer->relay_major_version = rsock->major; @@ -866,9 +915,11 @@ error: /* * Connect to the relayd using URI and send the socket to the right consumer. + * + * The consumer socket lock must be held by the caller. */ -static int send_consumer_relayd_socket(enum lttng_domain_type domain, - unsigned int session_id, struct lttng_uri *relayd_uri, +static int 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) @@ -879,7 +930,7 @@ static int send_consumer_relayd_socket(enum lttng_domain_type domain, /* Connect to relayd and make version check if uri is the control. */ ret = create_connect_relayd(relayd_uri, &rsock, consumer); if (ret != LTTNG_OK) { - goto error; + goto relayd_comm_error; } assert(rsock); @@ -919,10 +970,6 @@ static int send_consumer_relayd_socket(enum lttng_domain_type domain, */ close_sock: - (void) relayd_close(rsock); - free(rsock); - -error: if (ret != LTTNG_OK) { /* * The consumer output for this session should not be used anymore @@ -931,6 +978,10 @@ error: */ consumer->enabled = 0; } + (void) relayd_close(rsock); + free(rsock); + +relayd_comm_error: return ret; } @@ -938,6 +989,8 @@ error: * 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. */ static int send_consumer_relayd_sockets(enum lttng_domain_type domain, unsigned int session_id, struct consumer_output *consumer, @@ -951,7 +1004,7 @@ static int send_consumer_relayd_sockets(enum lttng_domain_type domain, /* Sending control relayd socket. */ if (!sock->control_sock_sent) { - ret = send_consumer_relayd_socket(domain, session_id, + ret = send_consumer_relayd_socket(session_id, &consumer->dst.net.control, consumer, sock, session_name, hostname, session_live_timer); if (ret != LTTNG_OK) { @@ -961,7 +1014,7 @@ static int send_consumer_relayd_sockets(enum lttng_domain_type domain, /* Sending data relayd socket. */ if (!sock->data_sock_sent) { - ret = send_consumer_relayd_socket(domain, session_id, + ret = send_consumer_relayd_socket(session_id, &consumer->dst.net.data, consumer, sock, session_name, hostname, session_live_timer); if (ret != LTTNG_OK) { @@ -1100,7 +1153,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; @@ -1317,13 +1370,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; } @@ -1422,10 +1495,6 @@ int cmd_disable_event(struct ltt_session *session, DBG("Disable event command for event \'%s\'", event->name); event_name = event->name; - if (validate_event_name(event_name)) { - ret = LTTNG_ERR_INVALID_EVENT_NAME; - goto error; - } /* Error out on unhandled search criteria */ if (event->loglevel_type || event->loglevel != -1 || event->enabled @@ -1599,6 +1668,16 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, 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; @@ -1667,7 +1746,7 @@ int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain, free(attr); goto error; } - free(attr); + channel_attr_destroy(attr); chan_ust_created = 1; } @@ -1717,43 +1796,6 @@ end: return ret; } -static int validate_event_name(const char *name) -{ - int ret = 0; - const char *c = name; - const char *event_name_end = c + LTTNG_SYMBOL_NAME_LEN; - bool null_terminated = false; - - /* - * Make sure that unescaped wildcards are only used as the last - * character of the event name. - */ - while (c < event_name_end) { - switch (*c) { - case '\0': - null_terminated = true; - 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++; - } -end: - if (!ret && !null_terminated) { - ret = LTTNG_ERR_INVALID_EVENT_NAME; - } - return ret; -} - 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); @@ -1799,8 +1841,8 @@ static int _cmd_enable_event(struct ltt_session *session, struct lttng_event_exclusion *exclusion, 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); @@ -1809,15 +1851,24 @@ static int _cmd_enable_event(struct ltt_session *session, /* If we have a filter, we must have its filter expression */ assert(!(!!filter_expression ^ !!filter)); - DBG("Enable event command for event \'%s\'", event->name); + /* Normalize event name as a globbing pattern */ + strutils_normalize_star_glob_pattern(event->name); - rcu_read_lock(); + /* Normalize exclusion names as globbing patterns */ + if (exclusion) { + size_t i; - ret = validate_event_name(event->name); - if (ret) { - goto error; + 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) { case LTTNG_DOMAIN_KERNEL: { @@ -1843,15 +1894,16 @@ static int _cmd_enable_event(struct ltt_session *session, 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; } @@ -1980,14 +2032,16 @@ static int _cmd_enable_event(struct ltt_session *session, 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( @@ -2047,6 +2101,12 @@ static int _cmd_enable_event(struct ltt_session *session, 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); @@ -2162,6 +2222,7 @@ error: free(filter_expression); free(filter); free(exclusion); + channel_attr_destroy(attr); rcu_read_unlock(); return ret; } @@ -2329,6 +2390,113 @@ error: 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. * @@ -2368,8 +2536,31 @@ int cmd_start_trace(struct ltt_session *session) 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; @@ -2395,12 +2586,70 @@ int cmd_start_trace(struct ltt_session *session) 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 = sessiond_rotate_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: return ret; } +static +int rename_active_chunk(struct ltt_session *session) +{ + int ret; + + session->current_archive_id++; + + /* + * The currently active tracing path is now the folder we + * want to rename. + */ + 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 active tracing path"); + goto end; + } + + ret = rename_complete_chunk(session, time(NULL)); + if (ret < 0) { + ERR("Failed to rename current rotate path"); + goto end; + } + + /* + * We just renamed, the folder, we didn't do an actual rotation, so + * the active tracing path is now the renamed folder and we have to + * restore the rotate count. + */ + ret = lttng_strncpy(session->rotation_chunk.active_tracing_path, + session->rotation_chunk.current_rotate_path, + sizeof(session->rotation_chunk.active_tracing_path)); + if (ret) { + ERR("Failed to rename active session chunk tracing path"); + goto end; + } +end: + session->current_archive_id--; + return ret; +} + /* * Command LTTNG_STOP_TRACE processed by the client thread. */ @@ -2410,9 +2659,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_occured = false; assert(session); + DBG("Begin stop session %s (id %" PRIu64 ")", session->name, session->id); /* Short cut */ ksession = session->kernel_session; usess = session->ust_session; @@ -2423,11 +2674,38 @@ int cmd_stop_trace(struct ltt_session *session) goto error; } + if (session->rotate_relay_pending_timer_enabled) { + sessiond_timer_rotate_pending_stop(session); + } + + if (session->rotate_timer_enabled) { + sessiond_rotate_timer_stop(session); + } + + if (session->current_archive_id > 0 && !session->rotate_pending) { + ret = rename_active_chunk(session); + if (ret) { + /* + * This error should not prevent the user from stopping + * the session. However, it will be reported at the end. + */ + error_occured = true; + } + } + /* Kernel tracer */ 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) { @@ -2435,7 +2713,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) { @@ -2443,15 +2721,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) { @@ -2470,7 +2742,7 @@ int cmd_stop_trace(struct ltt_session *session) /* Flag inactive after a successful stop. */ session->active = 0; - ret = LTTNG_OK; + ret = !error_occured ? LTTNG_OK : LTTNG_ERR_UNK; error: return ret; @@ -2694,7 +2966,8 @@ error: * * Called with session lock held. */ -int cmd_destroy_session(struct ltt_session *session, int wpipe) +int cmd_destroy_session(struct ltt_session *session, int wpipe, + struct notification_thread_handle *notification_thread_handle) { int ret; struct ltt_ust_session *usess; @@ -2706,6 +2979,30 @@ int cmd_destroy_session(struct ltt_session *session, int wpipe) usess = session->ust_session; ksess = session->kernel_session; + DBG("Begin destroy session %s (id %" PRIu64 ")", session->name, session->id); + + if (session->rotate_relay_pending_timer_enabled) { + sessiond_timer_rotate_pending_stop(session); + } + + if (session->rotate_timer_enabled) { + sessiond_rotate_timer_stop(session); + } + + if (session->rotate_size) { + unsubscribe_session_consumed_size_rotation(session, notification_thread_handle); + session->rotate_size = 0; + } + + /* + * The rename of the current chunk is performed at stop, but if we rotated + * the session after the previous stop command, we need to rename the + * new (and empty) chunk that was started in between. + */ + if (session->rotated_after_last_stop) { + rename_active_chunk(session); + } + /* Clean kernel session teardown */ kernel_destroy_session(ksess); @@ -2739,81 +3036,23 @@ int cmd_destroy_session(struct ltt_session *session, int wpipe) } /* - * Command LTTNG_CALIBRATE processed by the client thread. + * Command LTTNG_REGISTER_CONSUMER processed by the client thread. */ -int cmd_calibrate(enum lttng_domain_type 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; + int ret, sock; + struct consumer_socket *socket = NULL; + + assert(session); + assert(cdata); + assert(sock_path); 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, - enum lttng_domain_type domain, const char *sock_path, - struct consumer_data *cdata) -{ - int ret, sock; - struct consumer_socket *socket = NULL; - - assert(session); - assert(cdata); - assert(sock_path); - - switch (domain) { - case LTTNG_DOMAIN_KERNEL: - { - struct ltt_kernel_session *ksess = session->kernel_session; + struct ltt_kernel_session *ksess = session->kernel_session; assert(ksess); @@ -2988,8 +3227,8 @@ ssize_t cmd_list_channels(enum lttng_domain_type domain, if (nb_chan > 0) { const size_t channel_size = sizeof(struct lttng_channel) + - sizeof(struct lttcomm_channel_extended); - struct lttcomm_channel_extended *channel_exts; + sizeof(struct lttng_channel_extended); + struct lttng_channel_extended *channel_exts; payload_size = nb_chan * channel_size; *channels = zmalloc(payload_size); @@ -3000,7 +3239,12 @@ ssize_t cmd_list_channels(enum lttng_domain_type domain, channel_exts = ((void *) *channels) + (nb_chan * sizeof(struct lttng_channel)); - list_lttng_channels(domain, session, *channels, channel_exts); + ret = list_lttng_channels(domain, session, *channels, channel_exts); + if (ret != LTTNG_OK) { + free(*channels); + *channels = NULL; + goto end; + } } else { *channels = NULL; } @@ -3108,7 +3352,7 @@ 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"); @@ -3136,6 +3380,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; @@ -3157,6 +3403,15 @@ int cmd_data_pending(struct ltt_session *session) } } + /* + * A rotation is still pending, we have to wait. + */ + if (session->rotate_pending) { + 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) { @@ -3197,11 +3452,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; } @@ -3265,7 +3519,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; } @@ -3317,19 +3571,19 @@ 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; + goto end; } /* Copy list from session to the new list object. */ @@ -3339,10 +3593,18 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, 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, @@ -3367,11 +3629,335 @@ ssize_t cmd_snapshot_list_outputs(struct ltt_session *session, list = NULL; ret = session->snapshot.nb_output; error: + rcu_read_unlock(); free(list); +end: + return ret; +} + +/* + * Check if we can regenerate the metadata for this session. + * Only kernel, UST per-uid and non-live sessions are supported. + * + * Return 0 if the metadata can be generated, a LTTNG_ERR code otherwise. + */ +static +int check_regenerate_metadata_support(struct ltt_session *session) +{ + int ret; + + assert(session); + + 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; + +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; + } + + 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_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); + } + +end: rcu_read_unlock(); return ret; } +/* + * Command LTTNG_REGENERATE_METADATA from the lttng-ctl library. + * + * 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. + */ +int cmd_regenerate_metadata(struct ltt_session *session) +{ + int ret; + + assert(session); + + ret = check_regenerate_metadata_support(session); + if (ret) { + goto end; + } + + 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; + } + } + + 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; + +end: + return ret; +} + +/* + * Command LTTNG_REGENERATE_STATEDUMP from the lttng-ctl library. + * + * Ask the tracer to regenerate a new statedump. + * + * Return 0 on success or else a LTTNG_ERR code. + */ +int cmd_regenerate_statedump(struct ltt_session *session) +{ + int ret; + + assert(session); + + if (!session->active) { + ret = LTTNG_ERR_SESSION_NOT_STARTED; + goto end; + } + + 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; + } + } + + 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; + +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. @@ -3403,10 +3989,12 @@ static int set_relayd_for_snapshot(struct consumer_output *consumer, rcu_read_lock(); cds_lfht_for_each_entry(snap_output->consumer->socks->ht, &iter.iter, socket, node.node) { + pthread_mutex_lock(socket->lock); ret = send_consumer_relayd_sockets(0, session->id, snap_output->consumer, socket, session->name, session->hostname, session->live_timer); + pthread_mutex_unlock(socket->lock); if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; @@ -3433,13 +4021,6 @@ static int record_kernel_snapshot(struct ltt_kernel_session *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 @@ -3487,14 +4068,6 @@ static int record_ust_snapshot(struct ltt_ust_session *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; - } - /* * Copy UST session sockets so we can communicate with the right * consumer for the snapshot record command. @@ -3516,9 +4089,6 @@ static int record_ust_snapshot(struct ltt_ust_session *usess, case EINVAL: ret = LTTNG_ERR_INVALID; break; - case ENODATA: - ret = LTTNG_ERR_SNAPSHOT_NODATA; - break; default: ret = LTTNG_ERR_SNAPSHOT_FAIL; break; @@ -3636,18 +4206,27 @@ int cmd_snapshot_record(struct ltt_session *session, unsigned int use_tmp_output = 0; struct snapshot_output tmp_output; 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) { + 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; + ret = LTTNG_ERR_NOT_SNAPSHOT_SESSION; goto error; } @@ -3672,138 +4251,104 @@ int cmd_snapshot_record(struct ltt_session *session, } /* 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 (session->kernel_session) { - struct ltt_kernel_session *ksess = session->kernel_session; + if (use_tmp_output) { + int64_t nb_packets_per_stream; - 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) { + ret = LTTNG_ERR_MAX_SIZE_INVALID; + goto error; + } - nb_packets_per_stream = get_session_nb_packets_per_stream(session, - tmp_output.max_size); - if (nb_packets_per_stream < 0) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; + if (session->kernel_session) { + ret = record_kernel_snapshot(session->kernel_session, + &tmp_output, session, + wait, nb_packets_per_stream); + if (ret != LTTNG_OK) { goto error; } - ret = record_kernel_snapshot(ksess, &tmp_output, session, + } + + if (session->ust_session) { + ret = record_ust_snapshot(session->ust_session, + &tmp_output, session, wait, nb_packets_per_stream); if (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) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; - goto error; - } + snapshot_success = 1; + } else { + struct snapshot_output *sout; + struct lttng_ht_iter iter; - /* Use temporary name. */ - if (*output->name != '\0') { - strncpy(tmp_output.name, output->name, - sizeof(tmp_output.name)); - } + rcu_read_lock(); + cds_lfht_for_each_entry(session->snapshot.output_ht->ht, + &iter.iter, sout, node.node) { + int64_t nb_packets_per_stream; - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + /* + * 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 = record_kernel_snapshot(ksess, &tmp_output, - session, wait, nb_packets_per_stream); - if (ret != LTTNG_OK) { - rcu_read_unlock(); - goto error; - } - snapshot_success = 1; + if (output->max_size != (uint64_t) -1ULL) { + tmp_output.max_size = output->max_size; } - rcu_read_unlock(); - } - } - - if (session->ust_session) { - struct ltt_ust_session *usess = session->ust_session; - - 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) { ret = LTTNG_ERR_MAX_SIZE_INVALID; + rcu_read_unlock(); goto error; } - ret = record_ust_snapshot(usess, &tmp_output, session, - wait, nb_packets_per_stream); - if (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) { - ret = LTTNG_ERR_MAX_SIZE_INVALID; + /* Use temporary name. */ + if (*output->name != '\0') { + if (lttng_strncpy(tmp_output.name, output->name, + sizeof(tmp_output.name))) { + ret = LTTNG_ERR_INVALID; rcu_read_unlock(); goto error; } + } - /* Use temporary name. */ - if (*output->name != '\0') { - strncpy(tmp_output.name, output->name, - sizeof(tmp_output.name)); - } + tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + memcpy(tmp_output.datetime, datetime, sizeof(datetime)); - tmp_output.nb_snapshot = session->snapshot.nb_snapshot; + if (session->kernel_session) { + ret = record_kernel_snapshot(session->kernel_session, + &tmp_output, session, + wait, nb_packets_per_stream); + if (ret != LTTNG_OK) { + rcu_read_unlock(); + goto error; + } + } - ret = record_ust_snapshot(usess, &tmp_output, session, + if (session->ust_session) { + ret = record_ust_snapshot(session->ust_session, + &tmp_output, session, wait, nb_packets_per_stream); if (ret != LTTNG_OK) { rcu_read_unlock(); goto error; } - snapshot_success = 1; } - rcu_read_unlock(); + snapshot_success = 1; } + rcu_read_unlock(); } if (snapshot_success) { @@ -3839,6 +4384,486 @@ int cmd_set_session_shm_path(struct ltt_session *session, 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. + * + * Return LTTNG_OK on success or else a LTTNG_ERR code. + */ +int cmd_rotate_session(struct ltt_session *session, + struct lttng_rotate_session_return *rotate_return) +{ + int ret; + size_t strf_ret; + struct tm *timeinfo; + char datetime[21]; + time_t now; + bool ust_active = false; + + assert(session); + + if (!session->has_been_started) { + ret = -LTTNG_ERR_START_SESSION_ONCE; + goto end; + } + + if (session->live_timer || session->snapshot_mode || + !session->output_traces) { + 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)) { + ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE_RELAY; + goto end; + } + + if (session->rotate_pending || session->rotate_pending_relay) { + ret = -LTTNG_ERR_ROTATION_PENDING; + DBG("Rotate already in progress"); + goto end; + } + + /* + * After a stop, we only allow one rotation to occur, the other ones are + * useless until a new start. + */ + if (session->rotated_after_last_stop) { + DBG("Session \"%s\" was already rotated after stop, refusing rotation", + session->name); + 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; + + /* Either one of the two sessions is enough to get the root path. */ + if (session->kernel_session) { + base_path = session_get_base_path(session); + } else if (session->ust_session) { + base_path = session_get_base_path(session); + } else { + assert(0); + } + assert(base_path); + 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + } else { + /* + * The currently active tracing path is now the folder we + * want to rotate. + */ + 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + } + DBG("Current rotate path %s", session->rotation_chunk.current_rotate_path); + + session->current_archive_id++; + session->rotate_pending = true; + session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + + /* + * Create the path name for the next chunk. + */ + now = time(NULL); + if (now == (time_t) -1) { + ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE; + goto end; + } + 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"); + 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + /* + * 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + /* + * 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); + ret = -LTTNG_ERR_CREATE_DIR_FAIL; + goto end; + } + ret = kernel_rotate_session(session); + if (ret != LTTNG_OK) { + ret = -ret; + goto end; + } + } + 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + 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"); + ret = -LTTNG_ERR_UNK; + goto end; + } + /* + * 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) { + ret = -LTTNG_ERR_CREATE_DIR_FAIL; + goto end; + } + ret = ust_app_rotate_session(session, &ust_active); + if (ret != LTTNG_OK) { + goto end; + } + /* + * Handle the case where we did not start a rotation on any channel. + * The consumer will never wake up the rotation thread to perform the + * rename, so we have to do it here while we hold the session and + * session_list locks. + */ + if (!session->kernel_session && !ust_active) { + ret = rename_complete_chunk(session, now); + if (ret < 0) { + ERR("Failed to rename completed rotation chunk"); + goto end; + } + session->rotate_pending = false; + session->rotation_state = LTTNG_ROTATION_STATE_COMPLETED; + } + } + + if (!session->active) { + session->rotated_after_last_stop = true; + } + + if (rotate_return) { + rotate_return->rotation_id = session->current_archive_id; + } + + DBG("Cmd rotate session %s, current_archive_id %" PRIu64 " sent", + session->name, session->current_archive_id); + ret = LTTNG_OK; + +end: + return ret; +} + +/* + * 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; + + assert(session); + + DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name, + session->current_archive_id); + + 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; + } + + 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(); + } + + info_return->status = (int32_t) session->rotation_state; + ret = LTTNG_OK; +end: + return ret; +} + +/* + * Command LTTNG_ROTATION_SET_SCHEDULE from the lttng-ctl library. + * + * Configure the automatic rotation parameters. + * Set to -1ULL to disable them. + * + * Return 0 on success or else an LTTNG_ERR code. + */ +int cmd_rotation_set_schedule(struct ltt_session *session, + uint64_t timer_us, uint64_t size, + struct notification_thread_handle *notification_thread_handle) +{ + int ret; + + assert(session); + + DBG("Cmd rotate set schedule session %s", session->name); + + if (session->live_timer || session->snapshot_mode || + !session->output_traces) { + ret = LTTNG_ERR_ROTATION_NOT_AVAILABLE; + goto end; + } + + /* Trying to override an already active timer. */ + if (timer_us && timer_us != -1ULL && session->rotate_timer_period) { + ret = LTTNG_ERR_ROTATION_TIMER_SET; + goto end; + /* Trying to disable an inactive timer. */ + } else if (timer_us == -1ULL && !session->rotate_timer_period) { + ret = LTTNG_ERR_ROTATION_NO_TIMER_SET; + goto end; + } + + if (size && size != -1ULL && session->rotate_size) { + ret = LTTNG_ERR_ROTATION_SIZE_SET; + goto end; + } else if (size == -1ULL && !session->rotate_size) { + ret = LTTNG_ERR_ROTATION_NO_SIZE_SET; + goto end; + } + + if (timer_us && !session->rotate_timer_period) { + if (timer_us > UINT_MAX) { + ret = LTTNG_ERR_INVALID; + goto end; + } + + session->rotate_timer_period = timer_us; + /* + * Only start the timer if the session is active, otherwise + * it will be started when the session starts. + */ + if (session->active) { + ret = sessiond_rotate_timer_start(session, timer_us); + if (ret) { + ERR("Failed to enable rotate timer"); + ret = LTTNG_ERR_UNK; + goto end; + } + } + } else if (timer_us == -1ULL && session->rotate_timer_period > 0) { + sessiond_rotate_timer_stop(session); + session->rotate_timer_period = 0; + } + + if (size > 0) { + if (size == -1ULL) { + ret = unsubscribe_session_consumed_size_rotation(session, + notification_thread_handle); + if (ret) { + ret = LTTNG_ERR_UNK; + goto end; + } + session->rotate_size = 0; + } else { + ret = subscribe_session_consumed_size_rotation(session, + size, notification_thread_handle); + if (ret) { + PERROR("Subscribe to session usage"); + ret = LTTNG_ERR_UNK; + goto end; + } + session->rotate_size = size; + } + } + + ret = LTTNG_OK; + + goto end; + +end: + return ret; +} + +/* + * Command ROTATE_GET_CURRENT_PATH from the lttng-ctl library. + * + * Configure the automatic rotation parameters. + * Set to -1ULL to disable them. + * + * Return LTTNG_OK on success or else a LTTNG_ERR code. + */ +int cmd_session_get_current_output(struct ltt_session *session, + struct lttng_session_get_current_output_return *output_return) +{ + int ret; + const char *path; + + if (!session->snapshot_mode) { + if (session->current_archive_id == 0) { + if (session->kernel_session) { + path = session_get_base_path(session); + } else if (session->ust_session) { + path = session_get_base_path(session); + } else { + abort(); + } + assert(path); + } else { + path = session->rotation_chunk.active_tracing_path; + } + } else { + /* + * A snapshot session does not have a "current" trace archive + * location. + */ + path = ""; + } + + DBG("Cmd get current output for session %s, returning %s", + session->name, path); + + ret = lttng_strncpy(output_return->path, + path, + sizeof(output_return->path)); + if (ret) { + ERR("Failed to copy trace output path to session get current output command reply"); + ret = -LTTNG_ERR_UNK; + goto end; + } + + ret = LTTNG_OK; +end: + return ret; +} + /* * Init command subsystem. */