struct cmd_destroy_session_reply_context {
int reply_sock_fd;
bool implicit_rotation_on_destroy;
+ /*
+ * Indicates whether or not an error occurred while launching the
+ * destruction of a session.
+ */
+ enum lttng_error_code destruction_status;
};
static enum lttng_error_code wait_on_path(void *path);
static int validate_ust_event_name(const char *);
static int cmd_enable_event_internal(struct ltt_session *session,
- struct lttng_domain *domain,
+ const struct lttng_domain *domain,
char *channel_name, struct lttng_event *event,
char *filter_expression,
struct lttng_filter_bytecode *filter,
ret = lttng_strncpy(consumer->dst.session_root_path,
uri->dst.path,
sizeof(consumer->dst.session_root_path));
+ if (ret) {
+ ret_code = LTTNG_ERR_FATAL;
+ goto error;
+ }
consumer->type = CONSUMER_DST_LOCAL;
break;
}
/*
* Start a kernel session by opening all necessary streams.
*/
-static int start_kernel_session(struct ltt_kernel_session *ksess, int wpipe)
+static int start_kernel_session(struct ltt_kernel_session *ksess)
{
int ret;
struct ltt_kernel_channel *kchan;
}
/* Quiescent wait after starting trace */
- kernel_wait_quiescent(wpipe);
+ kernel_wait_quiescent();
ksess->active = 1;
goto error;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
break;
}
case LTTNG_DOMAIN_UST:
goto error;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
break;
}
case LTTNG_DOMAIN_UST:
goto error;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
break;
}
case LTTNG_DOMAIN_UST:
* The wpipe arguments is used as a notifier for the kernel thread.
*/
int cmd_enable_channel(struct ltt_session *session,
- struct lttng_domain *domain, struct lttng_channel *attr, int wpipe)
+ const struct lttng_domain *domain, const struct lttng_channel *_attr, int wpipe)
{
int ret;
struct ltt_ust_session *usess = session->ust_session;
struct lttng_ht *chan_ht;
size_t len;
+ struct lttng_channel attr;
assert(session);
- assert(attr);
+ assert(_attr);
assert(domain);
- len = lttng_strnlen(attr->name, sizeof(attr->name));
+ attr = *_attr;
+ len = lttng_strnlen(attr.name, sizeof(attr.name));
/* Validate channel name */
- if (attr->name[0] == '.' ||
- memchr(attr->name, '/', len) != NULL) {
+ 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);
+ DBG("Enabling channel %s for session %s", attr.name, session->name);
rcu_read_lock();
* beacons for inactive streams.
*/
if (session->live_timer > 0) {
- attr->attr.live_timer_interval = session->live_timer;
- attr->attr.switch_timer_interval = 0;
+ attr.attr.live_timer_interval = session->live_timer;
+ attr.attr.switch_timer_interval = 0;
}
/* Check for feature support */
switch (domain->type) {
case LTTNG_DOMAIN_KERNEL:
{
- if (kernel_supports_ring_buffer_snapshot_sample_positions(kernel_tracer_fd) != 1) {
+ if (kernel_supports_ring_buffer_snapshot_sample_positions() != 1) {
/* Sampling position of buffer is not supported */
WARN("Kernel tracer does not support buffer monitoring. "
"Setting the monitor interval timer to 0 "
"(disabled) for channel '%s' of session '%s'",
- attr-> name, session->name);
- lttng_channel_set_monitor_timer_interval(attr, 0);
+ attr.name, session->name);
+ lttng_channel_set_monitor_timer_interval(&attr, 0);
}
break;
}
{
struct ltt_kernel_channel *kchan;
- kchan = trace_kernel_get_channel_by_name(attr->name,
+ kchan = trace_kernel_get_channel_by_name(attr.name,
session->kernel_session);
if (kchan == NULL) {
if (session->snapshot.nb_output > 0 ||
session->snapshot_mode) {
/* Enforce mmap output for snapshot sessions. */
- attr->attr.output = LTTNG_EVENT_MMAP;
+ attr.attr.output = LTTNG_EVENT_MMAP;
}
- ret = channel_kernel_create(session->kernel_session, attr, wpipe);
- if (attr->name[0] != '\0') {
+ ret = channel_kernel_create(session->kernel_session, &attr, wpipe);
+ if (attr.name[0] != '\0') {
session->kernel_session->has_non_default_channel = 1;
}
} else {
goto error;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
break;
}
case LTTNG_DOMAIN_UST:
* adhered to.
*/
if (domain->type == LTTNG_DOMAIN_JUL) {
- if (strncmp(attr->name, DEFAULT_JUL_CHANNEL_NAME,
+ if (strncmp(attr.name, DEFAULT_JUL_CHANNEL_NAME,
LTTNG_SYMBOL_NAME_LEN)) {
ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
} else if (domain->type == LTTNG_DOMAIN_LOG4J) {
- if (strncmp(attr->name, DEFAULT_LOG4J_CHANNEL_NAME,
+ if (strncmp(attr.name, DEFAULT_LOG4J_CHANNEL_NAME,
LTTNG_SYMBOL_NAME_LEN)) {
ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
}
} else if (domain->type == LTTNG_DOMAIN_PYTHON) {
- if (strncmp(attr->name, DEFAULT_PYTHON_CHANNEL_NAME,
+ if (strncmp(attr.name, DEFAULT_PYTHON_CHANNEL_NAME,
LTTNG_SYMBOL_NAME_LEN)) {
ret = LTTNG_ERR_INVALID_CHANNEL_NAME;
goto error;
chan_ht = usess->domain_global.channels;
- uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
+ uchan = trace_ust_find_channel_by_name(chan_ht, attr.name);
if (uchan == NULL) {
- ret = channel_ust_create(usess, attr, domain->buf_type);
- if (attr->name[0] != '\0') {
+ ret = channel_ust_create(usess, &attr, domain->buf_type);
+ if (attr.name[0] != '\0') {
usess->has_non_default_channel = 1;
}
} else {
goto error;
}
- if (ret == LTTNG_OK && attr->attr.output != LTTNG_EVENT_MMAP) {
+ if (ret == LTTNG_OK && attr.attr.output != LTTNG_EVENT_MMAP) {
session->has_non_mmap_channel = true;
}
error:
* Command LTTNG_DISABLE_EVENT processed by the client thread.
*/
int cmd_disable_event(struct ltt_session *session,
- enum lttng_domain_type domain, char *channel_name,
- struct lttng_event *event)
+ enum lttng_domain_type domain, const char *channel_name,
+ const struct lttng_event *event)
{
int ret;
- char *event_name;
+ const char *event_name;
DBG("Disable event command for event \'%s\'", event->name);
goto error_unlock;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
break;
}
case LTTNG_DOMAIN_UST:
* Command LTTNG_ADD_CONTEXT processed by the client thread.
*/
int cmd_add_context(struct ltt_session *session, enum lttng_domain_type domain,
- char *channel_name, struct lttng_event_context *ctx, int kwpipe)
+ char *channel_name, const struct lttng_event_context *ctx, int kwpipe)
{
int ret, chan_kern_created = 0, chan_ust_created = 0;
char *app_ctx_provider_name = NULL, *app_ctx_name = NULL;
* enable the events through which all "agent" events are funeled.
*/
static int _cmd_enable_event(struct ltt_session *session,
- struct lttng_domain *domain,
+ const struct lttng_domain *domain,
char *channel_name, struct lttng_event *event,
char *filter_expression,
struct lttng_filter_bytecode *filter,
goto error;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
break;
}
case LTTNG_DOMAIN_UST:
* Command LTTNG_ENABLE_EVENT processed by the client thread.
* We own filter, exclusion, and filter_expression.
*/
-int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain,
+int cmd_enable_event(struct ltt_session *session,
+ const struct lttng_domain *domain,
char *channel_name, struct lttng_event *event,
char *filter_expression,
struct lttng_filter_bytecode *filter,
* reserved names.
*/
static int cmd_enable_event_internal(struct ltt_session *session,
- struct lttng_domain *domain,
+ const struct lttng_domain *domain,
char *channel_name, struct lttng_event *event,
char *filter_expression,
struct lttng_filter_bytecode *filter,
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
- nb_events = kernel_list_events(kernel_tracer_fd, events);
+ nb_events = kernel_list_events(events);
if (nb_events < 0) {
ret = LTTNG_ERR_KERN_LIST_FAIL;
goto error;
/* Kernel tracing */
if (ksession != NULL) {
DBG("Start kernel tracing session %s", session->name);
- ret = start_kernel_session(ksession, kernel_tracer_fd);
+ ret = start_kernel_session(ksession);
if (ret != LTTNG_OK) {
goto error;
}
goto error;
}
- kernel_wait_quiescent(kernel_tracer_fd);
+ kernel_wait_quiescent();
/* Flush metadata after stopping (if exists) */
if (ksession->metadata_stream_fd >= 0) {
ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
if (ret < 0) {
ERR("Kernel metadata flush failed");
+ error_occurred = true;
}
}
ret = kernel_flush_buffer(kchan);
if (ret < 0) {
ERR("Kernel flush buffer error");
+ error_occurred = true;
}
}
goto error;
}
+ for (i = 0; i < nb_uri; i++) {
+ if (uris[i].stype != LTTNG_STREAM_CONTROL ||
+ uris[i].subdir[0] == '\0') {
+ /* Not interested in these URIs */
+ continue;
+ }
+
+ if (session->base_path != NULL) {
+ free(session->base_path);
+ session->base_path = NULL;
+ }
+
+ /* Set session base_path */
+ session->base_path = strdup(uris[i].subdir);
+ if (!session->base_path) {
+ PERROR("Copying base path: %s", uris[i].subdir);
+ goto error;
+ }
+ DBG2("Setting base path for session %" PRIu64 ": %s",
+ session->id, session->base_path);
+ }
+
/* Set the "global" consumer URIs */
for (i = 0; i < nb_uri; i++) {
- ret = add_uri_to_consumer(session,
- session->consumer,
- &uris[i], LTTNG_DOMAIN_NONE);
+ ret = add_uri_to_consumer(session, session->consumer, &uris[i],
+ LTTNG_DOMAIN_NONE);
if (ret != LTTNG_OK) {
goto error;
}
const char *session_name;
struct ltt_session *new_session = NULL;
enum lttng_session_descriptor_status descriptor_status;
- const char *base_path;
session_lock_list();
if (home_path) {
ret_code = LTTNG_ERR_INVALID;
goto end;
}
- ret = lttng_session_descriptor_get_base_path(descriptor, &base_path);
- if (ret) {
- ret_code = LTTNG_ERR_INVALID;
- goto end;
- }
+
ret_code = session_create(session_name, creds->uid, creds->gid,
- base_path, &new_session);
+ &new_session);
if (ret_code != LTTNG_OK) {
goto end;
}
struct lttng_trace_archive_location *location = NULL;
struct lttcomm_lttng_msg llm = {
.cmd_type = LTTNG_DESTROY_SESSION,
- .ret_code = LTTNG_OK,
+ .ret_code = reply_context->destruction_status,
.pid = UINT32_MAX,
.cmd_header_size =
sizeof(struct lttcomm_session_destroy_command_header),
int *sock_fd)
{
int ret;
+ enum lttng_error_code destruction_last_error = LTTNG_OK;
struct cmd_destroy_session_reply_context *reply_context = NULL;
if (sock_fd) {
/* Carry on with the destruction of the session. */
ERR("Failed to stop session \"%s\" as part of its destruction: %s",
session->name, lttng_strerror(-ret));
+ destruction_last_error = ret;
}
}
session)) {
ERR("Failed to stop the \"rotation schedule\" timer of session %s",
session->name);
+ destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR;
}
}
if (ret != LTTNG_OK) {
ERR("Failed to perform an implicit rotation as part of the destruction of session \"%s\": %s",
session->name, lttng_strerror(-ret));
+ destruction_last_error = -ret;
}
if (reply_context) {
reply_context->implicit_rotation_on_destroy = true;
if (ret != LTTNG_OK) {
ERR("Failed to perform a quiet rotation as part of the destruction of session \"%s\": %s",
session->name, lttng_strerror(-ret));
+ destruction_last_error = -ret;
}
}
*/
session_destroy(session);
if (reply_context) {
+ reply_context->destruction_status = destruction_last_error;
ret = session_add_destroy_notifier(session,
cmd_destroy_session_reply,
(void *) reply_context);
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
int cmd_snapshot_add_output(struct ltt_session *session,
- struct lttng_snapshot_output *output, uint32_t *id)
+ const struct lttng_snapshot_output *output, uint32_t *id)
{
int ret;
struct snapshot_output *new_output;
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
int cmd_snapshot_del_output(struct ltt_session *session,
- struct lttng_snapshot_output *output)
+ const struct lttng_snapshot_output *output)
{
int ret;
struct snapshot_output *sout = NULL;
session->kernel_session->consumer;
snapshot_kernel_consumer_output =
consumer_copy_output(snapshot_output->consumer);
+ strcpy(snapshot_kernel_consumer_output->chunk_path,
+ snapshot_chunk_name);
ret = consumer_copy_sockets(snapshot_kernel_consumer_output,
original_kernel_consumer_output);
if (ret < 0) {
original_ust_consumer_output = session->ust_session->consumer;
snapshot_ust_consumer_output =
consumer_copy_output(snapshot_output->consumer);
+ strcpy(snapshot_ust_consumer_output->chunk_path,
+ snapshot_chunk_name);
ret = consumer_copy_sockets(snapshot_ust_consumer_output,
original_ust_consumer_output);
if (ret < 0) {
}
if (session_close_trace_chunk(
- session, session->current_trace_chunk, NULL)) {
+ session, session->current_trace_chunk, NULL, NULL)) {
/*
* Don't goto end; make sure the chunk is closed for the session
* to allow future snapshots.
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
int cmd_snapshot_record(struct ltt_session *session,
- struct lttng_snapshot_output *output, int wait)
+ const struct lttng_snapshot_output *output, int wait)
{
enum lttng_error_code cmd_ret = LTTNG_OK;
int ret;
struct lttng_trace_chunk *chunk_being_archived = NULL;
struct lttng_trace_chunk *new_trace_chunk = NULL;
enum lttng_trace_chunk_status chunk_status;
+ bool failed_to_rotate = false;
+ enum lttng_error_code rotation_fail_code = LTTNG_OK;
assert(session);
}
}
- /* The current trace chunk becomes the chunk being archived. */
+ /*
+ * The current trace chunk becomes the chunk being archived.
+ *
+ * After this point, "chunk_being_archived" must absolutely
+ * be closed on the consumer(s), otherwise it will never be
+ * cleaned-up, which will result in a leak.
+ */
ret = session_set_trace_chunk(session, new_trace_chunk,
&chunk_being_archived);
if (ret) {
if (session->kernel_session) {
cmd_ret = kernel_rotate_session(session);
if (cmd_ret != LTTNG_OK) {
- goto error;
+ failed_to_rotate = true;
+ rotation_fail_code = cmd_ret;
}
}
if (session->ust_session) {
cmd_ret = ust_app_rotate_session(session);
if (cmd_ret != LTTNG_OK) {
- goto error;
+ failed_to_rotate = true;
+ rotation_fail_code = cmd_ret;
}
}
quiet_rotation ?
NULL :
&((enum lttng_trace_chunk_command_type){
- LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}));
+ LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED}),
+ session->last_chunk_path);
if (ret) {
cmd_ret = LTTNG_ERR_CLOSE_TRACE_CHUNK_FAIL_CONSUMER;
goto error;
}
+ if (failed_to_rotate) {
+ cmd_ret = rotation_fail_code;
+ goto error;
+ }
+
session->quiet_rotation = quiet_rotation;
ret = timer_session_rotation_pending_check_start(session,
DEFAULT_ROTATE_PENDING_TIMER);
switch (rotation_state) {
case LTTNG_ROTATION_STATE_NO_ROTATION:
- DBG("Reporting that no rotation has occured within the lifetime of session \"%s\"",
+ DBG("Reporting that no rotation has occurred within the lifetime of session \"%s\"",
session->name);
goto end;
case LTTNG_ROTATION_STATE_EXPIRED:
sizeof(info_return->location.local.absolute_path);
info_return->location_type =
(int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL;
+ fmt_ret = asprintf(&chunk_path,
+ "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
+ session_get_base_path(session),
+ session->last_archived_chunk_name);
+ if (fmt_ret == -1) {
+ PERROR("Failed to format the path of the last archived trace chunk");
+ info_return->status = LTTNG_ROTATION_STATUS_ERROR;
+ cmd_ret = LTTNG_ERR_UNK;
+ goto end;
+ }
break;
case CONSUMER_DST_NET:
+ {
+ uint16_t ctrl_port, data_port;
+
current_tracing_path_reply =
info_return->location.relay.relative_path;
current_tracing_path_reply_len =
goto end;
}
- session_get_net_consumer_ports(session,
- &info_return->location.relay.ports.control,
- &info_return->location.relay.ports.data);
+ session_get_net_consumer_ports(session, &ctrl_port, &data_port);
+ info_return->location.relay.ports.control = ctrl_port;
+ info_return->location.relay.ports.data = data_port;
info_return->location_type =
(int8_t) LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY;
+ chunk_path = strdup(session->last_chunk_path);
+ if (!chunk_path) {
+ ERR("Failed to allocate the path of the last archived trace chunk");
+ info_return->status = LTTNG_ROTATION_STATUS_ERROR;
+ cmd_ret = LTTNG_ERR_UNK;
+ goto end;
+ }
break;
+ }
default:
abort();
}
- fmt_ret = asprintf(&chunk_path,
- "%s/" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY "/%s",
- session_get_base_path(session),
- session->last_archived_chunk_name);
- if (fmt_ret == -1) {
- PERROR("Failed to format the path of the last archived trace chunk");
- info_return->status = LTTNG_ROTATION_STATUS_ERROR;
- cmd_ret = LTTNG_ERR_UNK;
- goto end;
- }
fmt_ret = lttng_strncpy(current_tracing_path_reply,
chunk_path, current_tracing_path_reply_len);