X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=aa030d3b1253f45a716cfa2386c8282c2173611a;hp=33ecff0622612239edadc978eef4d1da6540ee94;hb=967bc289202ddf847f0d48ede0a483e969726ac4;hpb=db906c125f293467e08c043f27d2797fb748b23e diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 33ecff062..aa030d3b1 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -28,6 +28,7 @@ #include #include #include +#include #include "channel.h" #include "consumer.h" @@ -39,6 +40,7 @@ #include "utils.h" #include "syscall.h" #include "agent.h" +#include "buffer-registry.h" #include "cmd.h" @@ -214,6 +216,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; } @@ -606,7 +609,7 @@ static int list_lttng_kernel_events(char *channel_name, goto error; } - extended_at = ((uint8_t *) events) + + extended_at = ((void *) *events) + nb_event * sizeof(struct lttng_event); /* Kernel channels */ @@ -803,7 +806,8 @@ error: * Else, it's stays untouched and a lttcomm error code is returned. */ static int create_connect_relayd(struct lttng_uri *uri, - struct lttcomm_relayd_sock **relayd_sock) + struct lttcomm_relayd_sock **relayd_sock, + struct consumer_output *consumer) { int ret; struct lttcomm_relayd_sock *rsock; @@ -839,6 +843,8 @@ static int create_connect_relayd(struct lttng_uri *uri, ret = LTTNG_ERR_RELAYD_VERSION_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 { @@ -874,7 +880,7 @@ static int send_consumer_relayd_socket(enum lttng_domain_type domain, struct lttcomm_relayd_sock *rsock = NULL; /* Connect to relayd and make version check if uri is the control. */ - ret = create_connect_relayd(relayd_uri, &rsock); + ret = create_connect_relayd(relayd_uri, &rsock, consumer); if (ret != LTTNG_OK) { goto error; } @@ -1009,6 +1015,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 @@ -1027,6 +1037,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: @@ -3361,6 +3375,156 @@ error: 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_metadata_regenerate_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 ust_metadata_regenerate(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++; + 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_METADATA_REGENERATE 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_metadata_regenerate(struct ltt_session *session) +{ + int ret; + + assert(session); + + ret = check_metadata_regenerate_support(session); + if (ret) { + goto end; + } + + if (session->kernel_session) { + ret = kernctl_session_metadata_regenerate( + session->kernel_session->fd); + if (ret < 0) { + ERR("Failed to regenerate the kernel metadata"); + goto end; + } + } + + if (session->ust_session) { + ret = ust_metadata_regenerate(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; +} + + /* * Send relayd sockets from snapshot output to consumer. Ignore request if the * snapshot output is *not* set with a remote destination.