+ cds_lfht_for_each_entry(viewer_streams_ht->ht, &iter.iter, vstream,
+ stream_n.node) {
+ struct ctf_trace *ctf_trace;
+
+ health_code_update();
+
+ if (!viewer_stream_get(vstream)) {
+ continue;
+ }
+
+ pthread_mutex_lock(&vstream->stream->lock);
+ /* Ignore if not the same session. */
+ if (vstream->stream->trace->session->id != session_id ||
+ (!ignore_sent_flag && vstream->sent_flag)) {
+ pthread_mutex_unlock(&vstream->stream->lock);
+ viewer_stream_put(vstream);
+ continue;
+ }
+
+ ctf_trace = vstream->stream->trace;
+ send_stream.id = htobe64(vstream->stream->stream_handle);
+ send_stream.ctf_trace_id = htobe64(ctf_trace->id);
+ send_stream.metadata_flag = htobe32(
+ vstream->stream->is_metadata);
+ if (lttng_strncpy(send_stream.path_name, vstream->path_name,
+ sizeof(send_stream.path_name))) {
+ pthread_mutex_unlock(&vstream->stream->lock);
+ viewer_stream_put(vstream);
+ ret = -1; /* Error. */
+ goto end_unlock;
+ }
+ if (lttng_strncpy(send_stream.channel_name,
+ vstream->channel_name,
+ sizeof(send_stream.channel_name))) {
+ pthread_mutex_unlock(&vstream->stream->lock);
+ viewer_stream_put(vstream);
+ ret = -1; /* Error. */
+ goto end_unlock;
+ }
+
+ DBG("Sending stream %" PRIu64 " to viewer",
+ vstream->stream->stream_handle);
+ vstream->sent_flag = 1;
+ pthread_mutex_unlock(&vstream->stream->lock);
+
+ ret = send_response(sock, &send_stream, sizeof(send_stream));
+ viewer_stream_put(vstream);
+ if (ret < 0) {
+ goto end_unlock;
+ }
+ }
+
+ ret = 0;
+
+end_unlock:
+ rcu_read_unlock();
+ return ret;
+}
+
+/*
+ * Create every viewer stream possible for the given session with the seek
+ * type. Three counters *can* be return which are in order the total amount of
+ * viewer stream of the session, the number of unsent stream and the number of
+ * stream created. Those counters can be NULL and thus will be ignored.
+ *
+ * session must be locked to ensure that we see either none or all initial
+ * streams for a session, but no intermediate state..
+ *
+ * Return 0 on success or else a negative value.
+ */
+static int make_viewer_streams(struct relay_session *session,
+ struct lttng_trace_chunk *viewer_trace_chunk,
+ enum lttng_viewer_seek seek_t,
+ uint32_t *nb_total,
+ uint32_t *nb_unsent,
+ uint32_t *nb_created,
+ bool *closed)
+{
+ int ret;
+ struct lttng_ht_iter iter;
+ struct ctf_trace *ctf_trace;
+
+ assert(session);
+ ASSERT_LOCKED(session->lock);
+
+ if (!viewer_trace_chunk) {
+ ERR("Internal error: viewer session associated with session \"%s\" has a NULL trace chunk",
+ session->session_name);
+ ret = -1;
+ goto error;
+ }
+
+ if (session->connection_closed) {
+ *closed = true;
+ }
+
+ /*
+ * Create viewer streams for relay streams that are ready to be
+ * used for a the given session id only.
+ */
+ rcu_read_lock();
+ cds_lfht_for_each_entry(session->ctf_traces_ht->ht, &iter.iter, ctf_trace,
+ node.node) {
+ bool trace_has_metadata_stream = false;
+ struct relay_stream *stream;
+
+ health_code_update();
+
+ if (!ctf_trace_get(ctf_trace)) {
+ continue;
+ }
+
+ /*
+ * Iterate over all the streams of the trace to see if we have a
+ * metadata stream.
+ */
+ cds_list_for_each_entry_rcu(
+ stream, &ctf_trace->stream_list, stream_node)
+ {
+ if (stream->is_metadata) {
+ trace_has_metadata_stream = true;
+ break;
+ }
+ }
+
+ /*
+ * If there is no metadata stream in this trace at the moment
+ * and we never sent one to the viewer, skip the trace. We
+ * accept that the viewer will not see this trace at all.
+ */
+ if (!trace_has_metadata_stream &&
+ !ctf_trace->metadata_stream_sent_to_viewer) {
+ ctf_trace_put(ctf_trace);
+ continue;
+ }
+
+ cds_list_for_each_entry_rcu(stream, &ctf_trace->stream_list, stream_node) {
+ struct relay_viewer_stream *vstream;
+
+ if (!stream_get(stream)) {
+ continue;
+ }
+ /*
+ * stream published is protected by the session lock.
+ */
+ if (!stream->published) {
+ goto next;
+ }
+ vstream = viewer_stream_get_by_id(stream->stream_handle);
+ if (!vstream) {
+ /*
+ * Save that we sent the metadata stream to the
+ * viewer. So that we know what trace the viewer
+ * is aware of.
+ */
+ if (stream->is_metadata) {
+ ctf_trace->metadata_stream_sent_to_viewer =
+ true;
+ }
+ vstream = viewer_stream_create(stream,
+ viewer_trace_chunk, seek_t);
+ if (!vstream) {
+ ret = -1;
+ ctf_trace_put(ctf_trace);
+ stream_put(stream);
+ goto error_unlock;
+ }
+
+ if (nb_created) {
+ /* Update number of created stream counter. */
+ (*nb_created)++;
+ }
+ /*
+ * Ensure a self-reference is preserved even
+ * after we have put our local reference.
+ */
+ if (!viewer_stream_get(vstream)) {
+ ERR("Unable to get self-reference on viewer stream, logic error.");
+ abort();
+ }
+ } else {
+ if (!vstream->sent_flag && nb_unsent) {
+ /* Update number of unsent stream counter. */
+ (*nb_unsent)++;
+ }
+ }
+ /* Update number of total stream counter. */
+ if (nb_total) {
+ if (stream->is_metadata) {
+ if (!stream->closed ||
+ stream->metadata_received > vstream->metadata_sent) {
+ (*nb_total)++;
+ }
+ } else {
+ if (!stream->closed ||
+ !(((int64_t) (stream->prev_data_seq - stream->last_net_seq_num)) >= 0)) {
+
+ (*nb_total)++;
+ }
+ }
+ }
+ /* Put local reference. */
+ viewer_stream_put(vstream);
+ next:
+ stream_put(stream);
+ }
+ ctf_trace_put(ctf_trace);
+ }
+
+ ret = 0;
+
+error_unlock:
+ rcu_read_unlock();
+error:
+ return ret;
+}
+
+int relayd_live_stop(void)
+{
+ /* Stop dispatch thread */