#include <common/relayd/relayd.h>
#include <common/utils.h>
#include <common/compat/string.h>
+#include <common/kernel-ctl/kernel-ctl.h>
#include "channel.h"
#include "consumer.h"
#include "utils.h"
#include "syscall.h"
#include "agent.h"
+#include "buffer-registry.h"
#include "cmd.h"
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 += uchan->per_pid_closed_app_lost;
} else {
ERR("Unsupported buffer type");
+ assert(0);
ret = -1;
goto end;
}
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);
channels[i].attr.overwrite = uchan->attr.overwrite;
* 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;
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 {
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;
}
/* 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
/* 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:
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.
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));
+ /* Use temporary name. */
+ if (*output->name != '\0') {
+ strncpy(tmp_output.name, output->name,
+ sizeof(tmp_output.name));
+ }
- if (output->max_size != (uint64_t) -1ULL) {
- tmp_output.max_size = output->max_size;
- }
+ tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
- 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) {
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;
-
- 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) {
projects / lttng-tools.git / blobdiff