X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fsession.c;h=6eda624efad6f784c79cc96f66c5a22c5ceff36b;hp=03bec43fd9284009fbdb7e07e85519d8116f7746;hb=ce0b1d61919f37517a6212f7af2afe0fa1b1dcb0;hpb=ab5be9fa2eb5ba9600a82cd18fd3cfcbac69169a diff --git a/src/bin/lttng-sessiond/session.c b/src/bin/lttng-sessiond/session.c index 03bec43fd..6eda624ef 100644 --- a/src/bin/lttng-sessiond/session.c +++ b/src/bin/lttng-sessiond/session.c @@ -471,7 +471,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, CONSUMER_DST_LOCAL; session->ust_session->current_trace_chunk = new_trace_chunk; - if (is_local_trace) { + if (is_local_trace) { enum lttng_error_code ret_error_code; ret_error_code = ust_app_create_channel_subdirectories( @@ -479,7 +479,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, if (ret_error_code != LTTNG_OK) { goto error; } - } + } cds_lfht_for_each_entry( session->ust_session->consumer->socks->ht, &iter, socket, node.node) { @@ -489,11 +489,11 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, session->id, new_trace_chunk, DEFAULT_UST_TRACE_DIR); pthread_mutex_unlock(socket->lock); - if (ret) { + if (ret) { goto error; - } - } - } + } + } + } if (session->kernel_session) { const uint64_t relayd_id = session->kernel_session->consumer->net_seq_index; @@ -510,7 +510,7 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, if (ret_error_code != LTTNG_OK) { goto error; } - } + } cds_lfht_for_each_entry( session->kernel_session->consumer->socks->ht, &iter, socket, node.node) { @@ -520,11 +520,11 @@ int _session_set_trace_chunk_no_lock_check(struct ltt_session *session, session->id, new_trace_chunk, DEFAULT_KERNEL_TRACE_DIR); pthread_mutex_unlock(socket->lock); - if (ret) { + if (ret) { goto error; - } - } - } + } + } + } /* * Update local current trace chunk state last, only if all remote @@ -548,7 +548,7 @@ error: if (session->kernel_session) { session->kernel_session->current_trace_chunk = NULL; } - /* + /* * Release references taken in the case where all references could not * be acquired. */ @@ -574,8 +574,8 @@ struct lttng_trace_chunk *session_create_new_trace_chunk( const char *base_path; struct lttng_directory_handle *session_output_directory = NULL; const struct lttng_credentials session_credentials = { - .uid = session->uid, - .gid = session->gid, + .uid = LTTNG_OPTIONAL_INIT_VALUE(session->uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(session->gid), }; uint64_t next_chunk_id; const struct consumer_output *output; @@ -792,6 +792,83 @@ end: return ret; } +/* + * This function skips the metadata channel as the begin/end timestamps of a + * metadata packet are useless. + * + * Moreover, opening a packet after a "clear" will cause problems for live + * sessions as it will introduce padding that was not part of the first trace + * chunk. The relay daemon expects the content of the metadata stream of + * successive metadata trace chunks to be strict supersets of one another. + * + * For example, flushing a packet at the beginning of the metadata stream of + * a trace chunk resulting from a "clear" session command will cause the + * size of the metadata stream of the new trace chunk to not match the size of + * the metadata stream of the original chunk. This will confuse the relay + * daemon as the same "offset" in a metadata stream will no longer point + * to the same content. + */ +static +enum lttng_error_code session_kernel_open_packets(struct ltt_session *session) +{ + enum lttng_error_code ret = LTTNG_OK; + struct consumer_socket *socket; + struct lttng_ht_iter iter; + struct cds_lfht_node *node; + struct ltt_kernel_channel *chan; + + rcu_read_lock(); + + cds_lfht_first(session->kernel_session->consumer->socks->ht, &iter.iter); + node = cds_lfht_iter_get_node(&iter.iter); + socket = container_of(node, typeof(*socket), node.node); + + cds_list_for_each_entry(chan, + &session->kernel_session->channel_list.head, list) { + int open_ret; + + DBG("Open packet of kernel channel: channel key = %" PRIu64 + ", session name = %s, session_id = %" PRIu64, + chan->key, session->name, session->id); + + open_ret = consumer_open_channel_packets(socket, chan->key); + if (open_ret < 0) { + /* General error (no known error expected). */ + ret = LTTNG_ERR_UNK; + goto end; + } + } + +end: + rcu_read_unlock(); + return ret; +} + +enum lttng_error_code session_open_packets(struct ltt_session *session) +{ + enum lttng_error_code ret = LTTNG_OK; + + DBG("Opening packets of session channels: session name = %s, session id = %" PRIu64, + session->name, session->id); + + if (session->ust_session) { + ret = ust_app_open_packets(session); + if (ret != LTTNG_OK) { + goto end; + } + } + + if (session->kernel_session) { + ret = session_kernel_open_packets(session); + if (ret != LTTNG_OK) { + goto end; + } + } + +end: + return ret; +} + /* * Set a session's current trace chunk. * @@ -855,7 +932,7 @@ void session_release(struct urcu_ref *ref) usess = session->ust_session; ksess = session->kernel_session; - /* Clean kernel session teardown, keeping data for destroy notifier. */ + /* Clean kernel session teardown, keeping data for destroy notifier. */ kernel_destroy_session(ksess); /* UST session teardown, keeping data for destroy notifier. */ @@ -912,6 +989,7 @@ void session_release(struct urcu_ref *ref) * Broadcast after free-ing to ensure the memory is * reclaimed before the main thread exits. */ + ASSERT_LOCKED(ltt_session_list.lock); pthread_cond_broadcast(<t_session_list.removal_cond); } } @@ -1219,18 +1297,13 @@ error: } /* - * Check if the UID or GID match the session. Root user has access to all + * Check if the UID matches the session. Root user has access to all * sessions. */ -int session_access_ok(struct ltt_session *session, uid_t uid, gid_t gid) +bool session_access_ok(struct ltt_session *session, uid_t uid) { assert(session); - - if (uid != session->uid && gid != session->gid && uid != 0) { - return 0; - } else { - return 1; - } + return (uid == session->uid) || uid == 0; } /*