#define _GNU_SOURCE
#define _LGPL_SOURCE
#include <assert.h>
+#include <string.h>
#include <inttypes.h>
#include <urcu/list.h>
#include <urcu/uatomic.h>
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,
- 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);
-
/*
* Create a session path used by list_lttng_sessions for the case that the
* session consumer is on the network.
}
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;
+ }
+
+ ret = LTTNG_OK;
+
+error:
+ rcu_read_unlock();
+ return ret;
+}
+
+/*
+ * Command LTTNG_TRACK_PID processed by the client thread.
+ *
+ * Called with session lock held.
+ */
+int cmd_track_pid(struct ltt_session *session, int 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_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, int 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;
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 = 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();
error:
rcu_read_unlock();
+end:
return ret;
}
-
/*
* Command LTTNG_DISABLE_EVENT processed by the client thread.
*/
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);
- }
rcu_read_lock();
switch (event->type) {
case LTTNG_EVENT_ALL:
- case LTTNG_EVENT_TRACEPOINT:
- ret = event_kernel_disable_tracepoint(kchan, event_name);
+ ret = event_kernel_disable_event_all(kchan);
if (ret != LTTNG_OK) {
goto error;
}
break;
+ case LTTNG_EVENT_TRACEPOINT: /* fall-through */
case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_disable_syscall(kchan, event_name);
+ if (!strcmp(event_name, "*")) {
+ ret = event_kernel_disable_event_type(kchan,
+ event->type);
+ } else {
+ ret = event_kernel_disable_event(kchan,
+ event_name);
+ }
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ break;
+ case LTTNG_EVENT_PROBE:
+ case LTTNG_EVENT_FUNCTION:
+ case LTTNG_EVENT_FUNCTION_ENTRY:
+ ret = event_kernel_disable_event(kchan, event_name);
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;
- }
-
- ret = LTTNG_OK;
-
-error:
- 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;
-
- 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, "");
- if (ret != LTTNG_OK) {
- goto error;
- }
- break;
- default:
- ret = LTTNG_ERR_UNK;
- goto error;
- }
-
- kernel_wait_quiescent(kernel_tracer_fd);
- break;
- }
default:
ret = LTTNG_ERR_UND;
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;
DBG("Enable event command for event \'%s\'", event->name);
- /* 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);
- }
-
ret = validate_event_name(event->name);
if (ret) {
goto error;
switch (event->type) {
case LTTNG_EVENT_ALL:
+ {
+ event->type = LTTNG_EVENT_TRACEPOINT; /* Hack */
+ ret = event_kernel_enable_event(kchan, event);
+ if (ret != LTTNG_OK) {
+ if (channel_created) {
+ /* Let's not leak a useless channel. */
+ kernel_destroy_channel(kchan);
+ }
+ goto error;
+ }
+ event->type = LTTNG_EVENT_SYSCALL; /* Hack */
+ ret = event_kernel_enable_event(kchan, event);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ break;
+ }
case LTTNG_EVENT_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);
if (ret != LTTNG_OK) {
if (channel_created) {
/* Let's not leak a useless channel. */
}
break;
case LTTNG_EVENT_SYSCALL:
- ret = event_kernel_enable_syscall(kchan, event->name);
+ ret = event_kernel_enable_event(kchan, event);
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 ret;
}
-/*
- * Command LTTNG_ENABLE_EVENT for event "*" processed by the client thread.
- */
-static
-int enable_kevent_all(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)
-{
- 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, "");
- if (ret != LTTNG_OK) {
- goto error;
- }
- 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;
-}
-
-
/*
* Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
*/
return syscall_table_list(events);
}
+/*
+ * Command LTTNG_LIST_TRACKER_PIDS processed by the client thread.
+ *
+ * Called with session lock held.
+ */
+ssize_t cmd_list_tracker_pids(struct ltt_session *session,
+ int domain, int32_t **pids)
+{
+ int ret;
+ ssize_t nr_pids = 0;
+
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ {
+ struct ltt_kernel_session *ksess;
+
+ 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;
+
+ 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;
+ }
+
+ return nr_pids;
+
+error:
+ /* Return negative value to differentiate return code */
+ return -ret;
+}
+
/*
* Command LTTNG_START_TRACE processed by the client thread.
+ *
+ * Called with session mutex held.
*/
int cmd_start_trace(struct ltt_session *session)
{
/*
* 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);
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).
session->output_traces = 1;
if (ksess) {
ksess->output_traces = 1;
- } else if (usess) {
+ }
+
+ if (usess) {
usess->output_traces = 1;
}
}
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;
}
/*
* Command LTTNG_DESTROY_SESSION processed by the client thread.
+ *
+ * Called with session lock held.
*/
int cmd_destroy_session(struct ltt_session *session, int wpipe)
{
*/
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 wait, uint64_t nb_packets_per_stream)
{
int ret;
goto error_snapshot;
}
- ret = kernel_snapshot_record(ksess, output, wait, max_stream_size);
+ ret = kernel_snapshot_record(ksess, output, wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
goto error_snapshot;
}
ret = LTTNG_OK;
+ goto end;
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;
}
*/
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 wait, uint64_t nb_packets_per_stream)
{
int ret;
goto error_snapshot;
}
- ret = ust_app_snapshot_record(usess, output, wait, max_stream_size);
+ ret = ust_app_snapshot_record(usess, output, wait, nb_packets_per_stream);
if (ret < 0) {
switch (-ret) {
case EINVAL:
return ret;
}
-/*
- * Return the biggest subbuffer size of all channels in the given session.
- */
-static uint64_t get_session_max_subbuf_size(struct ltt_session *session)
+static
+uint64_t get_session_size_one_more_packet_per_stream(struct ltt_session *session,
+ uint64_t cur_nr_packets)
{
- uint64_t max_size = 0;
-
- assert(session);
+ 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;
- rcu_read_lock();
- 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;
- }
- }
- rcu_read_unlock();
+ 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;
}
/*
int ret = LTTNG_OK;
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;
assert(session);
assert(output);
use_tmp_output = 1;
}
- /*
- * Get the session maximum size for a snapshot meaning it will compute the
- * size of all streams from all domain.
- */
- max_stream_size = get_session_max_subbuf_size(session);
-
- nb_streams = get_session_nb_streams(session);
- if (nb_streams) {
- /*
- * 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.
- */
- session_max_size = max_stream_size * nb_streams;
- }
-
- DBG3("Snapshot max size is %" PRIu64 " for max stream size of %" PRIu64,
- session_max_size, max_stream_size);
-
- /*
- * If we use a temporary output, check right away if the max size fits else
- * for each output the max size will be checked.
- */
- if (use_tmp_output &&
- (tmp_output.max_size != 0 &&
- tmp_output.max_size < session_max_size)) {
- ret = LTTNG_ERR_MAX_SIZE_INVALID;
- goto error;
- }
-
if (session->kernel_session) {
struct ltt_kernel_session *ksess = session->kernel_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;
+ goto error;
+ }
ret = record_kernel_snapshot(ksess, &tmp_output, session,
- wait, max_stream_size);
+ wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
goto error;
}
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 max size. */
if (output->max_size != (uint64_t) -1ULL) {
tmp_output.max_size = output->max_size;
}
- if (tmp_output.max_size != 0 &&
- tmp_output.max_size < session_max_size) {
- rcu_read_unlock();
+ 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;
}
tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
ret = record_kernel_snapshot(ksess, &tmp_output,
- session, wait, max_stream_size);
+ session, wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
rcu_read_unlock();
goto error;
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;
+ goto error;
+ }
ret = record_ust_snapshot(usess, &tmp_output, session,
- wait, max_stream_size);
+ wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
goto error;
}
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 max size. */
if (output->max_size != (uint64_t) -1ULL) {
tmp_output.max_size = output->max_size;
}
- if (tmp_output.max_size != 0 &&
- tmp_output.max_size < session_max_size) {
- rcu_read_unlock();
+ 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;
}
tmp_output.nb_snapshot = session->snapshot.nb_snapshot;
ret = record_ust_snapshot(usess, &tmp_output, session,
- wait, max_stream_size);
+ wait, nb_packets_per_stream);
if (ret != LTTNG_OK) {
rcu_read_unlock();
goto error;
return 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;
+}
+
/*
* Init command subsystem.
*/