goto error;
}
+ /*
+ * Do we have a UST url set. If yes, this means we have both kernel and UST
+ * to print.
+ */
if (strlen(tmp_uurl) > 0) {
ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
tmp_urls, kdata_port, tmp_uurl, udata_port);
} else {
- ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, kdata_port);
+ int dport;
+ if (kuri) {
+ dport = kdata_port;
+ } else {
+ /* No kernel URI, use the UST port. */
+ dport = udata_port;
+ }
+ ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, dport);
}
error:
lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter);
node = lttng_ht_iter_get_node_str(&iter);
if (node == NULL) {
- ret = -LTTCOMM_UST_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
tmp = zmalloc(nb_event * sizeof(struct lttng_event));
if (tmp == NULL) {
- ret = -LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
if (kchan == NULL) {
- ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
goto error;
}
DBG("Listing events for channel %s", kchan->channel->name);
if (nb_event == 0) {
- ret = nb_event;
- goto error;
+ goto end;
}
*events = zmalloc(nb_event * sizeof(struct lttng_event));
if (*events == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
i++;
}
+end:
return nb_event;
error:
- return ret;
+ /* Negate the error code to differentiate the size from an error */
+ return -ret;
}
/*
static int add_uri_to_consumer(struct consumer_output *consumer,
struct lttng_uri *uri, int domain, const char *session_name)
{
- int ret = LTTCOMM_OK;
+ int ret = LTTNG_OK;
const char *default_trace_dir;
assert(uri);
if (consumer == NULL) {
DBG("No consumer detected. Don't add URI. Stopping.");
- ret = LTTCOMM_NO_CONSUMER;
+ ret = LTTNG_ERR_NO_CONSUMER;
goto error;
}
/* Set URI into consumer output object */
ret = consumer_set_network_uri(consumer, uri);
if (ret < 0) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
} else if (ret == 1) {
/*
if (uri->stype == LTTNG_STREAM_CONTROL && strlen(uri->subdir) == 0) {
ret = consumer_set_subdir(consumer, session_name);
if (ret < 0) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
}
assert(socket->fd >= 0);
pthread_mutex_lock(socket->lock);
- ret = kernel_consumer_send_session(socket->fd, session);
+ ret = kernel_consumer_send_session(socket, session);
pthread_mutex_unlock(socket->lock);
if (ret < 0) {
- ret = LTTCOMM_KERN_CONSUMER_FAIL;
+ ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
goto error;
}
}
/* Create socket object from URI */
sock = lttcomm_alloc_sock_from_uri(uri);
if (sock == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
ret = lttcomm_create_sock(sock);
if (ret < 0) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
ret = relayd_connect(sock);
if (ret < 0) {
ERR("Unable to reach lttng-relayd");
- ret = LTTCOMM_RELAYD_SESSION_FAIL;
+ ret = LTTNG_ERR_RELAYD_CONNECT_FAIL;
goto free_sock;
}
ret = relayd_version_check(sock, RELAYD_VERSION_COMM_MAJOR,
RELAYD_VERSION_COMM_MINOR);
if (ret < 0) {
- ret = LTTCOMM_RELAYD_VERSION_FAIL;
+ ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
goto close_sock;
}
} else if (uri->stype == LTTNG_STREAM_DATA) {
} else {
/* Command is not valid */
ERR("Relayd invalid stream type: %d", uri->stype);
- ret = LTTCOMM_INVALID;
+ ret = LTTNG_ERR_INVALID;
goto close_sock;
}
*relayd_sock = sock;
- return LTTCOMM_OK;
+ return LTTNG_OK;
close_sock:
if (sock) {
*/
static int send_consumer_relayd_socket(int domain, struct ltt_session *session,
struct lttng_uri *relayd_uri, struct consumer_output *consumer,
- int consumer_fd)
+ struct consumer_socket *consumer_sock)
{
int ret;
struct lttcomm_sock *sock = NULL;
/* Connect to relayd and make version check if uri is the control. */
ret = create_connect_relayd(consumer, session->name, relayd_uri, &sock);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto close_sock;
}
}
/* Send relayd socket to consumer. */
- ret = consumer_send_relayd_socket(consumer_fd, sock,
- consumer, relayd_uri->stype);
+ ret = consumer_send_relayd_socket(consumer_sock, sock,
+ consumer, relayd_uri->stype, session->id);
if (ret < 0) {
- ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
+ ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
goto close_sock;
}
- ret = LTTCOMM_OK;
+ /* Flag that the corresponding socket was sent. */
+ if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
+ consumer->dst.net.control_sock_sent = 1;
+ } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
+ consumer->dst.net.data_sock_sent = 1;
+ }
+
+ ret = LTTNG_OK;
/*
* Close socket which was dup on the consumer side. The session daemon does
* session.
*/
static int send_consumer_relayd_sockets(int domain,
- struct ltt_session *session, struct consumer_output *consumer, int fd)
+ struct ltt_session *session, struct consumer_output *consumer,
+ struct consumer_socket *sock)
{
- int ret;
+ int ret = LTTNG_OK;
assert(session);
assert(consumer);
- /* Don't resend the sockets to the consumer. */
- if (consumer->dst.net.relayd_socks_sent) {
- ret = LTTCOMM_OK;
- goto error;
- }
-
/* Sending control relayd socket. */
- ret = send_consumer_relayd_socket(domain, session,
- &consumer->dst.net.control, consumer, fd);
- if (ret != LTTCOMM_OK) {
- goto error;
+ if (!consumer->dst.net.control_sock_sent) {
+ ret = send_consumer_relayd_socket(domain, session,
+ &consumer->dst.net.control, consumer, sock);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
}
/* Sending data relayd socket. */
- ret = send_consumer_relayd_socket(domain, session,
- &consumer->dst.net.data, consumer, fd);
- if (ret != LTTCOMM_OK) {
- goto error;
+ if (!consumer->dst.net.data_sock_sent) {
+ ret = send_consumer_relayd_socket(domain, session,
+ &consumer->dst.net.data, consumer, sock);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
}
- /* Flag that all relayd sockets were sent to the consumer. */
- consumer->dst.net.relayd_socks_sent = 1;
-
error:
return ret;
}
*/
static int setup_relayd(struct ltt_session *session)
{
- int ret = LTTCOMM_OK;
+ int ret = LTTNG_OK;
struct ltt_ust_session *usess;
struct ltt_kernel_session *ksess;
struct consumer_socket *socket;
assert(socket->fd >= 0);
pthread_mutex_lock(socket->lock);
- send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session,
- usess->consumer, socket->fd);
+ ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session,
+ usess->consumer, socket);
pthread_mutex_unlock(socket->lock);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
}
assert(socket->fd >= 0);
pthread_mutex_lock(socket->lock);
- send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session,
- ksess->consumer, socket->fd);
+ ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session,
+ ksess->consumer, socket);
pthread_mutex_unlock(socket->lock);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ }
+ }
+
+error:
+ return ret;
+}
+
+/*
+ * Start a kernel session by opening all necessary streams.
+ */
+static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe)
+{
+ int ret;
+ struct ltt_kernel_channel *kchan;
+
+ /* Open kernel metadata */
+ if (ksess->metadata == NULL) {
+ ret = kernel_open_metadata(ksess);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_META_FAIL;
+ goto error;
+ }
+ }
+
+ /* Open kernel metadata stream */
+ if (ksess->metadata_stream_fd < 0) {
+ ret = kernel_open_metadata_stream(ksess);
+ if (ret < 0) {
+ ERR("Kernel create metadata stream failed");
+ ret = LTTNG_ERR_KERN_STREAM_FAIL;
+ goto error;
+ }
+ }
+
+ /* For each channel */
+ cds_list_for_each_entry(kchan, &ksess->channel_list.head, list) {
+ if (kchan->stream_count == 0) {
+ ret = kernel_open_channel_stream(kchan);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_STREAM_FAIL;
goto error;
}
+ /* Update the stream global counter */
+ ksess->stream_count_global += ret;
}
}
+ /* Setup kernel consumer socket and send fds to it */
+ ret = init_kernel_tracing(ksess);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_START_FAIL;
+ goto error;
+ }
+
+ /* This start the kernel tracing */
+ ret = kernel_start_session(ksess);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_START_FAIL;
+ goto error;
+ }
+
+ /* Quiescent wait after starting trace */
+ kernel_wait_quiescent(kernel_tracer_fd);
+
+ ksess->started = 1;
+
+ ret = LTTNG_OK;
+
error:
return ret;
}
{
ret = channel_kernel_disable(session->kernel_session,
channel_name);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
if (uchan == NULL) {
- ret = LTTCOMM_UST_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
ret = channel_ust_disable(usess, domain, uchan);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
break;
case LTTNG_DOMAIN_UST_PID:
#endif
default:
- ret = LTTCOMM_UNKNOWN_DOMAIN;
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
{
struct ltt_kernel_channel *kchan;
- /* Mandatory for a kernel channel. */
- assert(wpipe > 0);
-
kchan = trace_kernel_get_channel_by_name(attr->name,
session->kernel_session);
if (kchan == NULL) {
ret = channel_kernel_enable(session->kernel_session, kchan);
}
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
kernel_wait_quiescent(kernel_tracer_fd);
+
+ /*
+ * If the session was previously started, start as well this newly
+ * created kernel session so the events/channels enabled *after* the
+ * start actually work.
+ */
+ if (session->started && !session->kernel_session->started) {
+ ret = start_kernel_session(session->kernel_session, wpipe);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ }
break;
}
case LTTNG_DOMAIN_UST:
} else {
ret = channel_ust_enable(usess, domain, uchan);
}
+
+ /* Start the UST session if the session was already started. */
+ if (session->started && !usess->start_trace) {
+ ret = ust_app_start_trace_all(usess);
+ if (ret < 0) {
+ ret = LTTNG_ERR_UST_START_FAIL;
+ goto error;
+ }
+ ret = LTTNG_OK;
+ usess->start_trace = 1;
+ }
break;
}
#if 0
case LTTNG_DOMAIN_UST_PID:
#endif
default:
- ret = LTTCOMM_UNKNOWN_DOMAIN;
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
if (kchan == NULL) {
- ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
goto error;
}
ret = event_kernel_disable_tracepoint(ksess, kchan, event_name);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
channel_name);
if (uchan == NULL) {
- ret = LTTCOMM_UST_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
ret = event_ust_disable_tracepoint(usess, domain, uchan, event_name);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
#endif
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
if (kchan == NULL) {
- ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
goto error;
}
ret = event_kernel_disable_all(ksess, kchan);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
channel_name);
if (uchan == NULL) {
- ret = LTTCOMM_UST_CHAN_NOT_FOUND;
+ ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
goto error;
}
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
#endif
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
* Command LTTNG_ADD_CONTEXT processed by the client thread.
*/
int cmd_add_context(struct ltt_session *session, int domain,
- char *channel_name, char *event_name, struct lttng_event_context *ctx)
+ char *channel_name, struct lttng_event_context *ctx, int kwpipe)
{
int ret;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
+ assert(session->kernel_session);
+
+ if (session->kernel_session->channel_count == 0) {
+ /* Create default channel */
+ ret = channel_kernel_create(session->kernel_session, NULL, kwpipe);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ }
+
/* Add kernel context to kernel tracer */
- ret = context_kernel_add(session->kernel_session, ctx,
- event_name, channel_name);
- if (ret != LTTCOMM_OK) {
+ ret = context_kernel_add(session->kernel_session, ctx, channel_name);
+ if (ret != LTTNG_OK) {
goto error;
}
break;
case LTTNG_DOMAIN_UST:
{
struct ltt_ust_session *usess = session->ust_session;
-
assert(usess);
- ret = context_ust_add(usess, domain, ctx, event_name, channel_name);
- if (ret != LTTCOMM_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 = LTTCOMM_UND;
- goto error;
- }
-
- ret = LTTCOMM_OK;
-
-error:
- return ret;
-}
-
-/*
- * Command LTTNG_SET_FILTER processed by the client thread.
- */
-int cmd_set_filter(struct ltt_session *session, int domain,
- char *channel_name, char *event_name,
- struct lttng_filter_bytecode *bytecode)
-{
- int ret;
+ unsigned int chan_count =
+ lttng_ht_get_count(usess->domain_global.channels);
+ if (chan_count == 0) {
+ struct lttng_channel *attr;
+ /* Create default channel */
+ attr = channel_new_default_attr(domain);
+ if (attr == NULL) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
- switch (domain) {
- case LTTNG_DOMAIN_KERNEL:
- ret = LTTCOMM_FATAL;
- break;
- case LTTNG_DOMAIN_UST:
- {
- struct ltt_ust_session *usess = session->ust_session;
+ ret = channel_ust_create(usess, domain, attr);
+ if (ret != LTTNG_OK) {
+ free(attr);
+ goto error;
+ }
+ free(attr);
+ }
- ret = filter_ust_set(usess, domain, bytecode, event_name, channel_name);
- if (ret != LTTCOMM_OK) {
+ ret = context_ust_add(usess, domain, ctx, channel_name);
+ if (ret != LTTNG_OK) {
goto error;
}
break;
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
#endif
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
-
}
-
/*
* Command LTTNG_ENABLE_EVENT processed by the client thread.
*/
int cmd_enable_event(struct ltt_session *session, int domain,
- char *channel_name, struct lttng_event *event, int wpipe)
+ char *channel_name, struct lttng_event *event,
+ struct lttng_filter_bytecode *filter, int wpipe)
{
- int ret;
+ int ret, channel_created = 0;
struct lttng_channel *attr;
assert(session);
if (kchan == NULL) {
attr = channel_new_default_attr(domain);
if (attr == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
strncpy(attr->name, channel_name, sizeof(attr->name));
ret = cmd_enable_channel(session, domain, attr, wpipe);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
free(attr);
goto error;
}
free(attr);
+
+ channel_created = 1;
}
/* Get the newly created kernel channel pointer */
session->kernel_session);
if (kchan == NULL) {
/* This sould not happen... */
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
ret = event_kernel_enable_tracepoint(session->kernel_session, kchan,
event);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
+ if (channel_created) {
+ /* Let's not leak a useless channel. */
+ kernel_destroy_channel(kchan);
+ }
goto error;
}
/* Create default channel */
attr = channel_new_default_attr(domain);
if (attr == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
strncpy(attr->name, channel_name, sizeof(attr->name));
ret = cmd_enable_channel(session, domain, attr, wpipe);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
free(attr);
goto error;
}
}
/* At this point, the session and channel exist on the tracer */
- ret = event_ust_enable_tracepoint(usess, domain, uchan, event);
- if (ret != LTTCOMM_OK) {
+ ret = event_ust_enable_tracepoint(usess, domain, uchan, event, filter);
+ if (ret != LTTNG_OK) {
goto error;
}
break;
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
#endif
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
* Command LTTNG_ENABLE_ALL_EVENT processed by the client thread.
*/
int cmd_enable_event_all(struct ltt_session *session, int domain,
- char *channel_name, int event_type, int wpipe)
+ char *channel_name, int event_type,
+ struct lttng_filter_bytecode *filter, int wpipe)
{
int ret;
struct lttng_channel *attr;
/* Create default channel */
attr = channel_new_default_attr(domain);
if (attr == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
strncpy(attr->name, channel_name, sizeof(attr->name));
ret = cmd_enable_channel(session, domain, attr, wpipe);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
free(attr);
goto error;
}
kchan, kernel_tracer_fd);
break;
default:
- ret = LTTCOMM_KERN_ENABLE_FAIL;
+ ret = LTTNG_ERR_KERN_ENABLE_FAIL;
goto error;
}
/* Manage return value */
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
+ /*
+ * On error, cmd_enable_channel call will take care of destroying
+ * the created channel if it was needed.
+ */
goto error;
}
/* Create default channel */
attr = channel_new_default_attr(domain);
if (attr == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
strncpy(attr->name, channel_name, sizeof(attr->name));
ret = cmd_enable_channel(session, domain, attr, wpipe);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
free(attr);
goto error;
}
switch (event_type) {
case LTTNG_EVENT_ALL:
case LTTNG_EVENT_TRACEPOINT:
- ret = event_ust_enable_all_tracepoints(usess, domain, uchan);
- if (ret != LTTCOMM_OK) {
+ ret = event_ust_enable_all_tracepoints(usess, domain, uchan,
+ filter);
+ if (ret != LTTNG_OK) {
goto error;
}
break;
default:
- ret = LTTCOMM_UST_ENABLE_FAIL;
+ ret = LTTNG_ERR_UST_ENABLE_FAIL;
goto error;
}
/* Manage return value */
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
#endif
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
case LTTNG_DOMAIN_KERNEL:
nb_events = kernel_list_events(kernel_tracer_fd, events);
if (nb_events < 0) {
- ret = LTTCOMM_KERN_LIST_FAIL;
+ ret = LTTNG_ERR_KERN_LIST_FAIL;
goto error;
}
break;
case LTTNG_DOMAIN_UST:
nb_events = ust_app_list_events(events);
if (nb_events < 0) {
- ret = LTTCOMM_UST_LIST_FAIL;
+ ret = LTTNG_ERR_UST_LIST_FAIL;
goto error;
}
break;
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
case LTTNG_DOMAIN_UST:
nb_fields = ust_app_list_event_fields(fields);
if (nb_fields < 0) {
- ret = LTTCOMM_UST_LIST_FAIL;
+ ret = LTTNG_ERR_UST_LIST_FAIL;
goto error;
}
break;
case LTTNG_DOMAIN_KERNEL:
default: /* fall-through */
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
int ret;
struct ltt_kernel_session *ksession;
struct ltt_ust_session *usess;
- struct ltt_kernel_channel *kchan;
assert(session);
if (session->enabled) {
/* Already started. */
- ret = LTTCOMM_TRACE_ALREADY_STARTED;
+ ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
session->enabled = 1;
ret = setup_relayd(session);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
ERR("Error setting up relayd for session %s", session->name);
goto error;
}
/* Kernel tracing */
if (ksession != NULL) {
- /* Open kernel metadata */
- if (ksession->metadata == NULL) {
- ret = kernel_open_metadata(ksession);
- if (ret < 0) {
- ret = LTTCOMM_KERN_META_FAIL;
- goto error;
- }
- }
-
- /* Open kernel metadata stream */
- if (ksession->metadata_stream_fd < 0) {
- ret = kernel_open_metadata_stream(ksession);
- if (ret < 0) {
- ERR("Kernel create metadata stream failed");
- ret = LTTCOMM_KERN_STREAM_FAIL;
- goto error;
- }
- }
-
- /* For each channel */
- cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
- if (kchan->stream_count == 0) {
- ret = kernel_open_channel_stream(kchan);
- if (ret < 0) {
- ret = LTTCOMM_KERN_STREAM_FAIL;
- goto error;
- }
- /* Update the stream global counter */
- ksession->stream_count_global += ret;
- }
- }
-
- /* Setup kernel consumer socket and send fds to it */
- ret = init_kernel_tracing(ksession);
- if (ret < 0) {
- ret = LTTCOMM_KERN_START_FAIL;
+ ret = start_kernel_session(ksession, kernel_tracer_fd);
+ if (ret != LTTNG_OK) {
goto error;
}
-
- /* This start the kernel tracing */
- ret = kernel_start_session(ksession);
- if (ret < 0) {
- ret = LTTCOMM_KERN_START_FAIL;
- goto error;
- }
-
- /* Quiescent wait after starting trace */
- kernel_wait_quiescent(kernel_tracer_fd);
}
/* Flag session that trace should start automatically */
ret = ust_app_start_trace_all(usess);
if (ret < 0) {
- ret = LTTCOMM_UST_START_FAIL;
+ ret = LTTNG_ERR_UST_START_FAIL;
goto error;
}
}
- ret = LTTCOMM_OK;
+ session->started = 1;
+
+ ret = LTTNG_OK;
error:
return ret;
usess = session->ust_session;
if (!session->enabled) {
- ret = LTTCOMM_TRACE_ALREADY_STOPPED;
+ ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
goto error;
}
ret = kernel_stop_session(ksession);
if (ret < 0) {
- ret = LTTCOMM_KERN_STOP_FAIL;
+ ret = LTTNG_ERR_KERN_STOP_FAIL;
goto error;
}
kernel_wait_quiescent(kernel_tracer_fd);
+
+ ksession->started = 0;
}
if (usess) {
ret = ust_app_stop_trace_all(usess);
if (ret < 0) {
- ret = LTTCOMM_UST_STOP_FAIL;
+ ret = LTTNG_ERR_UST_STOP_FAIL;
goto error;
}
}
- ret = LTTCOMM_OK;
+ session->started = 0;
+
+ ret = LTTNG_OK;
error:
return ret;
/* Can't enable consumer after session started. */
if (session->enabled) {
- ret = LTTCOMM_TRACE_ALREADY_STARTED;
- goto error;
- }
-
- if (!session->start_consumer) {
- ret = LTTCOMM_NO_CONSUMER;
+ ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
if (consumer == NULL) {
consumer = consumer_copy_output(ksess->consumer);
if (consumer == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
/* Trash the consumer subdir, we are about to set a new one. */
if (consumer == NULL) {
consumer = consumer_copy_output(usess->consumer);
if (consumer == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
/* Trash the consumer subdir, we are about to set a new one. */
/*
* Don't send relayd socket if URI is NOT remote or if the relayd
- * sockets for the session are already sent.
+ * socket for the session was already sent.
*/
if (uris[i].dtype == LTTNG_DST_PATH ||
- consumer->dst.net.relayd_socks_sent) {
+ (uris[i].stype == LTTNG_STREAM_CONTROL &&
+ consumer->dst.net.control_sock_sent) ||
+ (uris[i].stype == LTTNG_STREAM_DATA &&
+ consumer->dst.net.data_sock_sent)) {
continue;
}
pthread_mutex_lock(socket->lock);
ret = send_consumer_relayd_socket(domain, session, &uris[i],
- consumer, socket->fd);
+ consumer, socket);
pthread_mutex_unlock(socket->lock);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
rcu_read_unlock();
goto error;
}
}
/* All good! */
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
*/
session = session_find_by_name(name);
if (session != NULL) {
- ret = LTTCOMM_EXIST_SESS;
+ ret = LTTNG_ERR_EXIST_SESS;
goto find_error;
}
/* Create tracing session in the registry */
ret = session_create(name, path, LTTNG_SOCK_GET_UID_CRED(creds),
LTTNG_SOCK_GET_GID_CRED(creds));
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto session_error;
}
/* Create default consumer output for the session not yet created. */
session->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
if (session->consumer == NULL) {
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto consumer_error;
}
session->start_consumer = 1;
ret = cmd_set_consumer_uri(0, session, nb_uri, uris);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto consumer_error;
}
session->consumer->enabled = 1;
end:
- return LTTCOMM_OK;
+ return LTTNG_OK;
consumer_error:
session_destroy(session);
kcalibrate.type = calibrate->type;
ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate);
if (ret < 0) {
- ret = LTTCOMM_KERN_ENABLE_FAIL;
+ ret = LTTNG_ERR_KERN_ENABLE_FAIL;
goto error;
}
break;
ucalibrate.type = calibrate->type;
ret = ust_app_calibrate_glb(&ucalibrate);
if (ret < 0) {
- ret = LTTCOMM_UST_CALIBRATE_FAIL;
+ ret = LTTNG_ERR_UST_CALIBRATE_FAIL;
goto error;
}
break;
}
default:
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
/* Can't register a consumer if there is already one */
if (ksess->consumer_fds_sent != 0) {
- ret = LTTCOMM_KERN_CONSUMER_FAIL;
+ ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
goto error;
}
sock = lttcomm_connect_unix_sock(sock_path);
if (sock < 0) {
- ret = LTTCOMM_CONNECT_FAIL;
+ ret = LTTNG_ERR_CONNECT_FAIL;
goto error;
}
socket = consumer_allocate_socket(sock);
if (socket == NULL) {
- ret = LTTCOMM_FATAL;
- close(sock);
+ ret = close(sock);
+ if (ret < 0) {
+ PERROR("close register consumer");
+ }
+ ret = LTTNG_ERR_FATAL;
goto error;
}
socket->lock = zmalloc(sizeof(pthread_mutex_t));
if (socket->lock == NULL) {
PERROR("zmalloc pthread mutex");
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
pthread_mutex_init(socket->lock, NULL);
}
default:
/* TODO: Userspace tracing */
- ret = LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
error:
return ret;
*domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
if (*domains == NULL) {
- ret = -LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
return nb_dom;
error:
- return ret;
+ /* Return negative value to differentiate return code */
+ return -ret;
}
nb_chan = session->kernel_session->channel_count;
}
DBG3("Number of kernel channels %zd", nb_chan);
+ if (nb_chan <= 0) {
+ ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
+ }
break;
case LTTNG_DOMAIN_UST:
if (session->ust_session != NULL) {
session->ust_session->domain_global.channels);
}
DBG3("Number of UST global channels %zd", nb_chan);
+ if (nb_chan <= 0) {
+ ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
+ }
break;
default:
*channels = NULL;
- ret = -LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
if (nb_chan > 0) {
*channels = zmalloc(nb_chan * sizeof(struct lttng_channel));
if (*channels == NULL) {
- ret = -LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
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;
error:
- return ret;
+ /* Return negative value to differentiate return code */
+ return -ret;
}
/*
break;
}
default:
- ret = -LTTCOMM_UND;
+ ret = LTTNG_ERR_UND;
goto error;
}
- ret = nb_event;
+ return nb_event;
error:
- return ret;
+ /* Return negative value to differentiate return code */
+ return -ret;
}
/*
if (session->enabled) {
/* Can't disable consumer on an already started session */
- ret = LTTCOMM_TRACE_ALREADY_STARTED;
+ ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
if (!session->start_consumer) {
- ret = LTTCOMM_NO_CONSUMER;
+ ret = LTTNG_ERR_NO_CONSUMER;
goto error;
}
break;
default:
- ret = LTTCOMM_UNKNOWN_DOMAIN;
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
goto error;
}
if (consumer) {
consumer->enabled = 0;
/* Success at this point */
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
} else {
- ret = LTTCOMM_NO_CONSUMER;
+ ret = LTTNG_ERR_NO_CONSUMER;
}
error:
/* Can't enable consumer after session started. */
if (session->enabled) {
- ret = LTTCOMM_TRACE_ALREADY_STARTED;
- goto error;
- }
-
- if (!session->start_consumer) {
- ret = LTTCOMM_NO_CONSUMER;
+ ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
goto error;
}
* had previously occured.
*/
if (ksess->consumer_fds_sent) {
- ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
+ ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
goto error;
}
consumer = ksess->tmp_consumer;
if (consumer == NULL) {
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
/* No temp. consumer output exists. Using the current one. */
DBG3("No temporary consumer. Using default");
consumer = ksess->consumer;
if (ret < 0) {
if (ret != -EEXIST) {
ERR("Trace directory creation error");
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
}
DBG2("Consumer output is network. Validating URIs");
/* Validate if we have both control and data path set. */
if (!consumer->dst.net.control_isset) {
- ret = LTTCOMM_URL_CTRL_MISS;
+ ret = LTTNG_ERR_URL_CTRL_MISS;
goto error;
}
if (!consumer->dst.net.data_isset) {
- ret = LTTCOMM_URL_DATA_MISS;
+ ret = LTTNG_ERR_URL_DATA_MISS;
goto error;
}
/* Check established network session state */
if (session->net_handle == 0) {
- ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
+ ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
ERR("Session network handle is not set on enable-consumer");
goto error;
}
break;
}
- /* Append default kernel trace dir to subdir */
- strncat(ksess->consumer->subdir, DEFAULT_KERNEL_TRACE_DIR,
- sizeof(ksess->consumer->subdir) -
- strlen(ksess->consumer->subdir) - 1);
-
/*
* @session-lock
* This is race free for now since the session lock is acquired before
* is valid.
*/
rcu_read_lock();
+ /* Destroy current consumer. We are about to replace it */
consumer_destroy_output(ksess->consumer);
rcu_read_unlock();
ksess->consumer = consumer;
* had previously occured.
*/
if (usess->start_trace) {
- ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
+ ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
goto error;
}
consumer = usess->tmp_consumer;
if (consumer == NULL) {
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
/* No temp. consumer output exists. Using the current one. */
DBG3("No temporary consumer. Using default");
consumer = usess->consumer;
if (ret < 0) {
if (ret != -EEXIST) {
ERR("Trace directory creation error");
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
goto error;
}
}
DBG2("Consumer output is network. Validating URIs");
/* Validate if we have both control and data path set. */
if (!consumer->dst.net.control_isset) {
- ret = LTTCOMM_URL_CTRL_MISS;
+ ret = LTTNG_ERR_URL_CTRL_MISS;
goto error;
}
if (!consumer->dst.net.data_isset) {
- ret = LTTCOMM_URL_DATA_MISS;
+ ret = LTTNG_ERR_URL_DATA_MISS;
goto error;
}
/* Check established network session state */
if (session->net_handle == 0) {
- ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
+ ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
DBG2("Session network handle is not set on enable-consumer");
goto error;
}
if (consumer->net_seq_index == -1) {
- ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
+ ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
DBG2("Network index is not set on the consumer");
goto error;
}
break;
}
- /* Append default kernel trace dir to subdir */
- strncat(usess->consumer->subdir, DEFAULT_UST_TRACE_DIR,
- sizeof(usess->consumer->subdir) -
- strlen(usess->consumer->subdir) - 1);
-
/*
* @session-lock
* This is race free for now since the session lock is acquired before
* is valid.
*/
rcu_read_lock();
+ /* Destroy current consumer. We are about to replace it */
consumer_destroy_output(usess->consumer);
rcu_read_unlock();
usess->consumer = consumer;
break;
}
+ session->start_consumer = 1;
+
/* Enable it */
if (consumer) {
consumer->enabled = 1;
/* Success at this point */
- ret = LTTCOMM_OK;
+ ret = LTTNG_OK;
} else {
/* Should not really happend... */
- ret = LTTCOMM_NO_CONSUMER;
+ ret = LTTNG_ERR_NO_CONSUMER;
}
error:
return ret;
}
+/*
+ * Command LTTNG_DATA_PENDING returning 0 if the data is NOT pending meaning
+ * ready for trace analysis (or anykind of reader) or else 1 for pending data.
+ */
+int cmd_data_pending(struct ltt_session *session)
+{
+ int ret;
+ struct ltt_kernel_session *ksess = session->kernel_session;
+ struct ltt_ust_session *usess = session->ust_session;
+
+ assert(session);
+
+ /* Session MUST be stopped to ask for data availability. */
+ if (session->enabled) {
+ ret = LTTNG_ERR_SESSION_STARTED;
+ goto error;
+ }
+
+ if (ksess && ksess->consumer) {
+ ret = consumer_is_data_pending(ksess->id, ksess->consumer);
+ if (ret == 1) {
+ /* Data is still being extracted for the kernel. */
+ goto error;
+ }
+ }
+
+ if (usess && usess->consumer) {
+ ret = consumer_is_data_pending(usess->id, usess->consumer);
+ if (ret == 1) {
+ /* Data is still being extracted for the kernel. */
+ goto error;
+ }
+ }
+
+ /* Data is ready to be read by a viewer */
+ ret = 0;
+
+error:
+ return ret;
+}
+
/*
* Init command subsystem.
*/
projects / lttng-tools.git / blobdiff