* URI was the same in the consumer so we do not append the subdir
* again so to not duplicate output dir.
*/
+ ret = LTTNG_OK;
goto error;
}
* Don't try to enable a channel if the session has been started at
* some point in time before. The tracer does not allow it.
*/
- if (session->started) {
+ if (session->has_been_started) {
ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
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;
+ goto error;
+ }
+
switch (domain->type) {
case LTTNG_DOMAIN_KERNEL:
{
kchan = trace_kernel_get_channel_by_name(attr->name,
session->kernel_session);
if (kchan == NULL) {
- /*
- * Don't try to create a channel if the session
- * has been started at some point in time
- * before. The tracer does not allow it.
- */
- if (session->started) {
- ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
- goto error;
- }
ret = channel_kernel_create(session->kernel_session, attr, wpipe);
if (attr->name[0] != '\0') {
session->kernel_session->has_non_default_channel = 1;
uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
if (uchan == NULL) {
- /*
- * Don't try to create a channel if the session
- * has been started at some point in time
- * before. The tracer does not allow it.
- */
- if (session->started) {
- ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
- goto error;
- }
ret = channel_ust_create(usess, attr, domain->buf_type);
if (attr->name[0] != '\0') {
usess->has_non_default_channel = 1;
memset(&uevent, 0, sizeof(uevent));
uevent.type = LTTNG_EVENT_TRACEPOINT;
uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
- strncpy(uevent.name, DEFAULT_JUL_EVENT_NAME, sizeof(uevent.name));
+ if (is_root) {
+ strncpy(uevent.name, DEFAULT_SYS_JUL_EVENT_NAME,
+ sizeof(uevent.name));
+ } else {
+ strncpy(uevent.name, DEFAULT_USER_JUL_EVENT_NAME,
+ sizeof(uevent.name));
+ }
uevent.name[sizeof(uevent.name) - 1] = '\0';
/*
tmp_dom.type = LTTNG_DOMAIN_UST;
ret = cmd_enable_event(session, &tmp_dom, DEFAULT_JUL_CHANNEL_NAME,
- &uevent, NULL, NULL, wpipe);
+ &uevent, filter, NULL, wpipe);
if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_ENABLED) {
goto error;
}
/* The wild card * means that everything should be enabled. */
if (strncmp(event->name, "*", 1) == 0 && strlen(event->name) == 1) {
- ret = event_jul_enable_all(usess, event);
+ ret = event_jul_enable_all(usess, event, filter);
} else {
- ret = event_jul_enable(usess, event);
+ ret = event_jul_enable(usess, event, filter);
}
if (ret != LTTNG_OK) {
goto error;
/* Create the default JUL tracepoint. */
uevent.type = LTTNG_EVENT_TRACEPOINT;
uevent.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
- strncpy(uevent.name, DEFAULT_JUL_EVENT_NAME, sizeof(uevent.name));
+ if (is_root) {
+ strncpy(uevent.name, DEFAULT_SYS_JUL_EVENT_NAME,
+ sizeof(uevent.name));
+ } else {
+ strncpy(uevent.name, DEFAULT_USER_JUL_EVENT_NAME,
+ sizeof(uevent.name));
+ }
uevent.name[sizeof(uevent.name) - 1] = '\0';
/*
strncpy(event.name, "*", sizeof(event.name));
event.name[sizeof(event.name) - 1] = '\0';
- ret = event_jul_enable_all(usess, &event);
+ ret = event_jul_enable_all(usess, &event, filter);
if (ret != LTTNG_OK) {
goto error;
}
ksession = session->kernel_session;
usess = session->ust_session;
- if (session->enabled) {
- /* Already started. */
+ /* Is the session already started? */
+ if (session->active) {
ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
* possible to enable channel thus inform the client.
*/
if (usess && usess->domain_global.channels) {
+ rcu_read_lock();
nb_chan += lttng_ht_get_count(usess->domain_global.channels);
+ rcu_read_unlock();
}
if (ksession) {
nb_chan += ksession->channel_count;
goto error;
}
- session->enabled = 1;
-
/* Kernel tracing */
if (ksession != NULL) {
ret = start_kernel_session(ksession, kernel_tracer_fd);
}
}
- session->started = 1;
+ /* Flag this after a successful start. */
+ session->has_been_started = 1;
+ session->active = 1;
ret = LTTNG_OK;
ksession = session->kernel_session;
usess = session->ust_session;
- if (!session->enabled) {
+ /* Session is not active. Skip everythong and inform the client. */
+ if (!session->active) {
ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
goto error;
}
- session->enabled = 0;
-
/* Kernel tracer */
if (ksession && ksession->started) {
DBG("Stop kernel tracing");
}
}
+ /* Flag inactive after a successful stop. */
+ session->active = 0;
ret = LTTNG_OK;
error:
assert(uris);
assert(nb_uri > 0);
- /* Can't enable consumer after session started. */
- if (session->enabled) {
+ /* Can't set consumer URI if the session is active. */
+ if (session->active) {
ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
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) {
+ usess->output_traces = 1;
+ }
+
/* All good! */
ret = LTTNG_OK;
break;
case LTTNG_DOMAIN_UST:
if (session->ust_session != NULL) {
+ rcu_read_lock();
nb_chan = lttng_ht_get_count(
- session->ust_session->domain_global.channels);
+ session->ust_session->domain_global.channels);
+ rcu_read_unlock();
}
DBG3("Number of UST global channels %zd", nb_chan);
- if (nb_chan <= 0) {
+ if (nb_chan < 0) {
ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
+ goto error;
}
break;
default:
- *channels = NULL;
ret = LTTNG_ERR_UND;
goto error;
}
}
list_lttng_channels(domain, session, *channels);
- } else {
- *channels = NULL;
- /* Ret value was set in the domain switch case */
- goto error;
}
return nb_chan;
strncpy(sessions[i].name, session->name, NAME_MAX);
sessions[i].name[NAME_MAX - 1] = '\0';
- sessions[i].enabled = session->enabled;
+ sessions[i].enabled = session->active;
sessions[i].snapshot_mode = session->snapshot_mode;
+ sessions[i].live_timer_interval = session->live_timer;
i++;
}
}
assert(session);
/* Session MUST be stopped to ask for data availability. */
- if (session->enabled) {
+ if (session->active) {
ret = LTTNG_ERR_SESSION_STARTED;
goto error;
+ } else {
+ /*
+ * If stopped, just make sure we've started before else the above call
+ * will always send that there is data pending.
+ *
+ * The consumer assumes that when the data pending command is received,
+ * the trace has been started before or else no output data is written
+ * by the streams which is a condition for data pending. So, this is
+ * *VERY* important that we don't ask the consumer before a start
+ * trace.
+ */
+ if (!session->has_been_started) {
+ ret = 0;
+ goto error;
+ }
}
if (ksess && ksess->consumer) {
struct lttng_snapshot_output **outputs)
{
int ret, idx = 0;
- struct lttng_snapshot_output *list;
+ struct lttng_snapshot_output *list = NULL;
struct lttng_ht_iter iter;
struct snapshot_output *output;
* set in no output mode.
*/
if (session->output_traces) {
- ret = LTTNG_ERR_EPERM;
+ ret = -LTTNG_ERR_EPERM;
goto error;
}
list = zmalloc(session->snapshot.nb_output * sizeof(*list));
if (!list) {
- ret = LTTNG_ERR_NOMEM;
+ ret = -LTTNG_ERR_NOMEM;
goto error;
}
/* Copy list from session to the new list object. */
+ rcu_read_lock();
cds_lfht_for_each_entry(session->snapshot.output_ht->ht, &iter.iter,
output, node.node) {
assert(output->consumer);
ret = uri_to_str_url(&output->consumer->dst.net.control,
list[idx].ctrl_url, sizeof(list[idx].ctrl_url));
if (ret < 0) {
- ret = LTTNG_ERR_NOMEM;
- goto free_error;
+ ret = -LTTNG_ERR_NOMEM;
+ goto error;
}
/* Data URI. */
ret = uri_to_str_url(&output->consumer->dst.net.data,
list[idx].data_url, sizeof(list[idx].data_url));
if (ret < 0) {
- ret = LTTNG_ERR_NOMEM;
- goto free_error;
+ ret = -LTTNG_ERR_NOMEM;
+ goto error;
}
}
idx++;
}
*outputs = list;
- return session->snapshot.nb_output;
-
-free_error:
- free(list);
+ list = NULL;
+ ret = session->snapshot.nb_output;
error:
- return -ret;
+ free(list);
+ rcu_read_unlock();
+ return ret;
}
/*
}
/* The session needs to be started at least once. */
- if (!session->started) {
+ if (!session->has_been_started) {
ret = LTTNG_ERR_START_SESSION_ONCE;
goto error;
}