X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fcmd.c;h=7c9477df938787407dc5eaf8b0c569ddfa0557a5;hp=82d92070398119fd60fce36adb55d17eb2aafc19;hb=3b61d9ee2a0611e980fb2817d6dd5fa3c9c7be68;hpb=7d268848fe44e591c53c8dfce796c6503c4539e8 diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c index 82d920703..7c9477df9 100644 --- a/src/bin/lttng-sessiond/cmd.c +++ b/src/bin/lttng-sessiond/cmd.c @@ -73,6 +73,11 @@ 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); @@ -107,7 +112,7 @@ static uint64_t relayd_net_seq_idx; 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, @@ -912,6 +917,10 @@ static enum lttng_error_code add_uri_to_consumer( 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; } @@ -1478,27 +1487,29 @@ error: * 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(); @@ -1517,8 +1528,8 @@ int cmd_enable_channel(struct ltt_session *session, * 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 */ @@ -1530,8 +1541,8 @@ int cmd_enable_channel(struct ltt_session *session, 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; } @@ -1556,16 +1567,16 @@ int cmd_enable_channel(struct ltt_session *session, { 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 { @@ -1595,19 +1606,19 @@ int cmd_enable_channel(struct ltt_session *session, * 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; @@ -1616,10 +1627,10 @@ int cmd_enable_channel(struct ltt_session *session, 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 { @@ -1632,7 +1643,7 @@ int cmd_enable_channel(struct ltt_session *session, 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: @@ -1645,11 +1656,11 @@ end: * 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); @@ -1822,7 +1833,7 @@ error: * 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; @@ -1993,7 +2004,7 @@ end: * 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, @@ -2390,7 +2401,8 @@ error: * 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, @@ -2407,7 +2419,7 @@ int cmd_enable_event(struct ltt_session *session, struct lttng_domain *domain, * 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, @@ -2560,6 +2572,8 @@ int cmd_start_trace(struct ltt_session *session) unsigned long nb_chan = 0; struct ltt_kernel_session *ksession; struct ltt_ust_session *usess; + const bool session_rotated_after_last_stop = + session->rotated_after_last_stop; assert(session); @@ -2573,6 +2587,22 @@ int cmd_start_trace(struct ltt_session *session) goto error; } + if (session->rotation_state == LTTNG_ROTATION_STATE_ONGOING && + !session->current_trace_chunk) { + /* + * A rotation was launched while the session was stopped and + * it has not been completed yet. It is not possible to start + * the session since starting the session here would require a + * rotation from "NULL" to a new trace chunk. That rotation + * would overlap with the ongoing rotation, which is not + * supported. + */ + WARN("Refusing to start session \"%s\" as a rotation launched after the last \"stop\" is still ongoing", + session->name); + ret = LTTNG_ERR_ROTATION_PENDING; + goto error; + } + /* * Starting a session without channel is useless since after that it's not * possible to enable channel thus inform the client. @@ -2588,21 +2618,45 @@ int cmd_start_trace(struct ltt_session *session) goto error; } + session->active = 1; + session->rotated_after_last_stop = false; if (session->output_traces && !session->current_trace_chunk) { - struct lttng_trace_chunk *trace_chunk; + if (!session->has_been_started) { + struct lttng_trace_chunk *trace_chunk; - trace_chunk = session_create_new_trace_chunk( - session, NULL, NULL, NULL); - if (!trace_chunk) { - ret = LTTNG_ERR_CREATE_DIR_FAIL; - goto error; - } - assert(!session->current_trace_chunk); - ret = session_set_trace_chunk(session, trace_chunk, NULL); - lttng_trace_chunk_put(trace_chunk); - if (ret) { - ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER; - goto error; + DBG("Creating initial trace chunk of session \"%s\"", + session->name); + trace_chunk = session_create_new_trace_chunk( + session, NULL, NULL, NULL); + if (!trace_chunk) { + ret = LTTNG_ERR_CREATE_DIR_FAIL; + goto error; + } + assert(!session->current_trace_chunk); + ret = session_set_trace_chunk(session, trace_chunk, + NULL); + lttng_trace_chunk_put(trace_chunk); + if (ret) { + ret = LTTNG_ERR_CREATE_TRACE_CHUNK_FAIL_CONSUMER; + goto error; + } + } else { + DBG("Rotating session \"%s\" from its current \"NULL\" trace chunk to a new chunk", + session->name); + /* + * Rotate existing streams into the new chunk. + * This is a "quiet" rotation has no client has + * explicitly requested this operation. + * + * There is also no need to wait for the rotation + * to complete as it will happen immediately. No data + * was produced as the session was stopped, so the + * rotation should happen on reception of the command. + */ + ret = cmd_rotate_session(session, NULL, true); + if (ret != LTTNG_OK) { + goto error; + } } } @@ -2625,10 +2679,6 @@ int cmd_start_trace(struct ltt_session *session) } } - /* Flag this after a successful start. */ - session->has_been_started = 1; - session->active = 1; - /* * Clear the flag that indicates that a rotation was done while the * session was stopped. @@ -2649,6 +2699,15 @@ int cmd_start_trace(struct ltt_session *session) ret = LTTNG_OK; error: + if (ret == LTTNG_OK) { + /* Flag this after a successful start. */ + session->has_been_started |= 1; + } else { + session->active = 0; + /* Restore initial state on error. */ + session->rotated_after_last_stop = + session_rotated_after_last_stop; + } return ret; } @@ -2693,6 +2752,7 @@ int cmd_stop_trace(struct ltt_session *session) ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd); if (ret < 0) { ERR("Kernel metadata flush failed"); + error_occurred = true; } } @@ -2701,6 +2761,7 @@ int cmd_stop_trace(struct ltt_session *session) ret = kernel_flush_buffer(kchan); if (ret < 0) { ERR("Kernel flush buffer error"); + error_occurred = true; } } @@ -2725,6 +2786,45 @@ error: return ret; } +/* + * Set the base_path of the session only if subdir of a control uris is set. + * Return LTTNG_OK on success, otherwise LTTNG_ERR_*. + */ +static int set_session_base_path_from_uris(struct ltt_session *session, + size_t nb_uri, + struct lttng_uri *uris) +{ + int ret; + size_t i; + + 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("Failed to copy base path \"%s\" to session \"%s\"", + uris[i].subdir, session->name); + ret = LTTNG_ERR_NOMEM; + goto error; + } + DBG2("Setting base path \"%s\" for session \"%s\"", + session->base_path, session->name); + } + ret = LTTNG_OK; +error: + return ret; +} + /* * Command LTTNG_SET_CONSUMER_URI processed by the client thread. */ @@ -2745,11 +2845,20 @@ int cmd_set_consumer_uri(struct ltt_session *session, size_t nb_uri, goto error; } + /* + * Set the session base path if any. This is done inside + * cmd_set_consumer_uri to preserve backward compatibility of the + * previous session creation api vs the session descriptor api. + */ + ret = set_session_base_path_from_uris(session, nb_uri, uris); + if (ret != LTTNG_OK) { + goto error; + } + /* 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; } @@ -2880,7 +2989,6 @@ enum lttng_error_code cmd_create_session_from_descriptor( 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) { @@ -2903,13 +3011,9 @@ enum lttng_error_code cmd_create_session_from_descriptor( 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; } @@ -3061,7 +3165,7 @@ void cmd_destroy_session_reply(const struct ltt_session *session, 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), @@ -3143,6 +3247,7 @@ int cmd_destroy_session(struct ltt_session *session, 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) { @@ -3167,6 +3272,7 @@ int cmd_destroy_session(struct ltt_session *session, /* 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; } } @@ -3175,6 +3281,7 @@ int cmd_destroy_session(struct ltt_session *session, session)) { ERR("Failed to stop the \"rotation schedule\" timer of session %s", session->name); + destruction_last_error = LTTNG_ERR_TIMER_STOP_ERROR; } } @@ -3194,6 +3301,7 @@ int cmd_destroy_session(struct ltt_session *session, 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; @@ -3212,6 +3320,7 @@ int cmd_destroy_session(struct ltt_session *session, 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; } } @@ -3276,6 +3385,7 @@ int cmd_destroy_session(struct ltt_session *session, */ 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); @@ -3706,7 +3816,7 @@ error: * 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; @@ -3774,7 +3884,7 @@ error: * 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; @@ -4602,7 +4712,7 @@ error: * 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; @@ -4768,6 +4878,8 @@ int cmd_rotate_session(struct ltt_session *session, 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); @@ -4813,9 +4925,6 @@ int cmd_rotate_session(struct ltt_session *session, cmd_ret = LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP; goto end; } - - session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; - if (session->active) { new_trace_chunk = session_create_new_trace_chunk(session, NULL, NULL, NULL); @@ -4825,7 +4934,13 @@ int cmd_rotate_session(struct ltt_session *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) { @@ -4833,24 +4948,41 @@ int cmd_rotate_session(struct ltt_session *session, goto error; } - assert(chunk_being_archived); - chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, - &ongoing_rotation_chunk_id); - assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); - 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) { + failed_to_rotate = true; + rotation_fail_code = cmd_ret; + } + } + + if (!session->active) { + session->rotated_after_last_stop = true; + } + + if (!chunk_being_archived) { + DBG("Rotating session \"%s\" from a \"NULL\" trace chunk to a new trace chunk, skipping completion check", + session->name); + if (failed_to_rotate) { + cmd_ret = rotation_fail_code; goto error; } + cmd_ret = LTTNG_OK; + goto end; } + session->rotation_state = LTTNG_ROTATION_STATE_ONGOING; + chunk_status = lttng_trace_chunk_get_id(chunk_being_archived, + &ongoing_rotation_chunk_id); + assert(chunk_status == LTTNG_TRACE_CHUNK_STATUS_OK); + ret = session_close_trace_chunk(session, chunk_being_archived, quiet_rotation ? NULL : @@ -4862,6 +4994,11 @@ int cmd_rotate_session(struct ltt_session *session, 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); @@ -4870,10 +5007,6 @@ int cmd_rotate_session(struct ltt_session *session, goto error; } - if (!session->active) { - session->rotated_after_last_stop = true; - } - if (rotate_return) { rotate_return->rotation_id = ongoing_rotation_chunk_id; } @@ -4948,7 +5081,7 @@ int cmd_rotate_get_info(struct ltt_session *session, 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: @@ -4989,6 +5122,9 @@ int cmd_rotate_get_info(struct ltt_session *session, } 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 = @@ -5007,9 +5143,9 @@ int cmd_rotate_get_info(struct ltt_session *session, 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); @@ -5020,6 +5156,7 @@ int cmd_rotate_get_info(struct ltt_session *session, goto end; } break; + } default: abort(); }