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;
}
}
if (uri->stype == LTTNG_STREAM_CONTROL) {
/* On a new subdir, reappend the default trace dir. */
- strncat(consumer->subdir, default_trace_dir, sizeof(consumer->subdir));
+ strncat(consumer->subdir, default_trace_dir,
+ sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
DBG3("Append domain trace name to subdir %s", consumer->subdir);
}
sizeof(consumer->dst.trace_path));
/* Append default trace dir */
strncat(consumer->dst.trace_path, default_trace_dir,
- sizeof(consumer->dst.trace_path));
+ sizeof(consumer->dst.trace_path) -
+ strlen(consumer->dst.trace_path) - 1);
/* Flag consumer as local. */
consumer->type = CONSUMER_DST_LOCAL;
break;
ret = kernel_consumer_send_session(socket->fd, 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) {
/* 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;
}
ret = consumer_send_relayd_socket(consumer_fd, sock,
consumer, relayd_uri->stype);
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
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, fd);
+ 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, fd);
+ 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;
send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session,
usess->consumer, socket->fd);
pthread_mutex_unlock(socket->lock);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
}
send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session,
ksess->consumer, socket->fd);
pthread_mutex_unlock(socket->lock);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
}
{
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;
ret = channel_kernel_enable(session->kernel_session, kchan);
}
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
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;
/* Add kernel context to kernel tracer */
ret = context_kernel_add(session->kernel_session, ctx,
event_name, channel_name);
- if (ret != LTTCOMM_OK) {
+ if (ret != LTTNG_OK) {
goto error;
}
break;
assert(usess);
ret = context_ust_add(usess, domain, ctx, event_name, channel_name);
- if (ret != LTTCOMM_OK) {
+ 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;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
- ret = LTTCOMM_FATAL;
+ ret = LTTNG_ERR_FATAL;
break;
case LTTNG_DOMAIN_UST:
{
struct ltt_ust_session *usess = session->ust_session;
ret = filter_ust_set(usess, domain, bytecode, event_name, channel_name);
- if (ret != LTTCOMM_OK) {
+ 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;
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;
}
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) {
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) {
+ 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;
/* 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) {
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;
}
case LTTNG_EVENT_ALL:
case LTTNG_EVENT_TRACEPOINT:
ret = event_ust_enable_all_tracepoints(usess, domain, uchan);
- if (ret != LTTCOMM_OK) {
+ 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;
}
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;
}
if (ksession->metadata == NULL) {
ret = kernel_open_metadata(ksession);
if (ret < 0) {
- ret = LTTCOMM_KERN_META_FAIL;
+ ret = LTTNG_ERR_KERN_META_FAIL;
goto error;
}
}
ret = kernel_open_metadata_stream(ksession);
if (ret < 0) {
ERR("Kernel create metadata stream failed");
- ret = LTTCOMM_KERN_STREAM_FAIL;
+ ret = LTTNG_ERR_KERN_STREAM_FAIL;
goto error;
}
}
if (kchan->stream_count == 0) {
ret = kernel_open_channel_stream(kchan);
if (ret < 0) {
- ret = LTTCOMM_KERN_STREAM_FAIL;
+ ret = LTTNG_ERR_KERN_STREAM_FAIL;
goto error;
}
/* Update the stream global counter */
/* Setup kernel consumer socket and send fds to it */
ret = init_kernel_tracing(ksession);
if (ret < 0) {
- ret = LTTCOMM_KERN_START_FAIL;
+ ret = LTTNG_ERR_KERN_START_FAIL;
goto error;
}
/* This start the kernel tracing */
ret = kernel_start_session(ksession);
if (ret < 0) {
- ret = LTTCOMM_KERN_START_FAIL;
+ ret = LTTNG_ERR_KERN_START_FAIL;
goto error;
}
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;
+ 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;
}
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;
+ 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;
}
ret = send_consumer_relayd_socket(domain, session, &uris[i],
consumer, socket->fd);
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;
+ ret = LTTNG_ERR_FATAL;
close(sock);
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;
}
/* Append default kernel trace dir to subdir */
strncat(ksess->consumer->subdir, DEFAULT_KERNEL_TRACE_DIR,
- sizeof(ksess->consumer->subdir));
+ sizeof(ksess->consumer->subdir) -
+ strlen(ksess->consumer->subdir) - 1);
/*
* @session-lock
* 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;
}
/* Append default kernel trace dir to subdir */
strncat(usess->consumer->subdir, DEFAULT_UST_TRACE_DIR,
- sizeof(usess->consumer->subdir));
+ sizeof(usess->consumer->subdir) -
+ strlen(usess->consumer->subdir) - 1);
/*
* @session-lock
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_AVAILABLE returning 0 if the data is NOT ready to be read
+ * or else 1 if the data is available for trace analysis.
+ */
+int cmd_data_available(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_available(ksess->id, ksess->consumer);
+ if (ret == 0) {
+ /* Data is still being extracted for the kernel. */
+ goto error;
+ }
+ }
+
+ if (usess && usess->consumer) {
+ ret = consumer_is_data_available(usess->id, usess->consumer);
+ if (ret == 0) {
+ /* Data is still being extracted for the kernel. */
+ goto error;
+ }
+ }
+
+ /* Data is ready to be read by a viewer */
+ ret = 1;
+
+error:
+ return ret;
+}
+
/*
* Init command subsystem.
*/
projects / lttng-tools.git / blobdiff