X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=src%2Fcommon%2Fconsumer%2Fconsumer.c;h=0c3dc35c2b3bb15b70e2018c85094f96d45487d1;hb=e3899a4d794d8ff3fcd40dc50c8ea2eefd5bf762;hp=22f223694270e67e28b70267c01579a846a1e53e;hpb=08eea91894d184f229e3aa991c6b581827eabd89;p=lttng-tools.git

diff --git a/src/common/consumer/consumer.c b/src/common/consumer/consumer.c
index 22f223694..0c3dc35c2 100644
--- a/src/common/consumer/consumer.c
+++ b/src/common/consumer/consumer.c
@@ -323,6 +323,7 @@ static void free_relayd_rcu(struct rcu_head *head)
 	(void) relayd_close(&relayd->control_sock);
 	(void) relayd_close(&relayd->data_sock);
 
+	pthread_mutex_destroy(&relayd->ctrl_sock_mutex);
 	free(relayd);
 }
 
@@ -464,14 +465,13 @@ static void update_endpoint_status_by_netidx(uint64_t net_seq_idx,
  * If a local data context is available, notify the threads that the streams'
  * state have changed.
  */
-static void cleanup_relayd(struct consumer_relayd_sock_pair *relayd,
-		struct lttng_consumer_local_data *ctx)
+void lttng_consumer_cleanup_relayd(struct consumer_relayd_sock_pair *relayd)
 {
 	uint64_t netidx;
 
 	assert(relayd);
 
-	DBG("Cleaning up relayd sockets");
+	DBG("Cleaning up relayd object ID %"PRIu64, relayd->net_seq_idx);
 
 	/* Save the net sequence index before destroying the object */
 	netidx = relayd->net_seq_idx;
@@ -491,10 +491,8 @@ static void cleanup_relayd(struct consumer_relayd_sock_pair *relayd,
 	 * memory barrier ordering the updates of the end point status from the
 	 * read of this status which happens AFTER receiving this notify.
 	 */
-	if (ctx) {
-		notify_thread_lttng_pipe(ctx->consumer_data_pipe);
-		notify_thread_lttng_pipe(ctx->consumer_metadata_pipe);
-	}
+	notify_thread_lttng_pipe(relayd->ctx->consumer_data_pipe);
+	notify_thread_lttng_pipe(relayd->ctx->consumer_metadata_pipe);
 }
 
 /*
@@ -802,6 +800,8 @@ int consumer_send_relayd_stream(struct lttng_consumer_stream *stream,
 				stream->chan->tracefile_size, stream->chan->tracefile_count);
 		pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
 		if (ret < 0) {
+			ERR("Relayd add stream failed. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+			lttng_consumer_cleanup_relayd(relayd);
 			goto end;
 		}
 
@@ -843,6 +843,8 @@ int consumer_send_relayd_streams_sent(uint64_t net_seq_idx)
 		ret = relayd_streams_sent(&relayd->control_sock);
 		pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
 		if (ret < 0) {
+			ERR("Relayd streams sent failed. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+			lttng_consumer_cleanup_relayd(relayd);
 			goto end;
 		}
 	} else {
@@ -1710,7 +1712,8 @@ write_error:
 	 * cleanup the relayd object and all associated streams.
 	 */
 	if (relayd && relayd_hang_up) {
-		cleanup_relayd(relayd, ctx);
+		ERR("Relayd hangup. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+		lttng_consumer_cleanup_relayd(relayd);
 	}
 
 end:
@@ -1936,7 +1939,8 @@ write_error:
 	 * cleanup the relayd object and all associated streams.
 	 */
 	if (relayd && relayd_hang_up) {
-		cleanup_relayd(relayd, ctx);
+		ERR("Relayd hangup. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+		lttng_consumer_cleanup_relayd(relayd);
 		/* Skip splice error so the consumer does not fail */
 		goto end;
 	}
@@ -3522,6 +3526,7 @@ error:
 	 * Add relayd socket pair to consumer data hashtable. If object already
 	 * exists or on error, the function gracefully returns.
 	 */
+	relayd->ctx = ctx;
 	add_relayd(relayd);
 
 	/* All good! */
@@ -3545,34 +3550,6 @@ error_nosignal:
 	}
 }
 
-/*
- * Try to lock the stream mutex.
- *
- * On success, 1 is returned else 0 indicating that the mutex is NOT lock.
- */
-static int stream_try_lock(struct lttng_consumer_stream *stream)
-{
-	int ret;
-
-	assert(stream);
-
-	/*
-	 * Try to lock the stream mutex. On failure, we know that the stream is
-	 * being used else where hence there is data still being extracted.
-	 */
-	ret = pthread_mutex_trylock(&stream->lock);
-	if (ret) {
-		/* For both EBUSY and EINVAL error, the mutex is NOT locked. */
-		ret = 0;
-		goto end;
-	}
-
-	ret = 1;
-
-end:
-	return ret;
-}
-
 /*
  * Search for a relayd associated to the session id and return the reference.
  *
@@ -3648,6 +3625,8 @@ int consumer_data_pending(uint64_t id)
 		pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
 		if (ret < 0) {
 			/* Communication error thus the relayd so no data pending. */
+			ERR("Relayd begin data pending failed. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+			lttng_consumer_cleanup_relayd(relayd);
 			goto data_not_pending;
 		}
 	}
@@ -3656,11 +3635,7 @@ int consumer_data_pending(uint64_t id)
 			ht->hash_fct(&id, lttng_ht_seed),
 			ht->match_fct, &id,
 			&iter.iter, stream, node_session_id.node) {
-		/* If this call fails, the stream is being used hence data pending. */
-		ret = stream_try_lock(stream);
-		if (!ret) {
-			goto data_pending;
-		}
+		pthread_mutex_lock(&stream->lock);
 
 		/*
 		 * A removed node from the hash table indicates that the stream has
@@ -3689,6 +3664,13 @@ int consumer_data_pending(uint64_t id)
 						stream->relayd_stream_id,
 						stream->next_net_seq_num - 1);
 			}
+			if (ret < 0) {
+				ERR("Relayd data pending failed. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+				lttng_consumer_cleanup_relayd(relayd);
+				pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
+				pthread_mutex_unlock(&stream->lock);
+				goto data_not_pending;
+			}
 			pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
 			if (ret == 1) {
 				pthread_mutex_unlock(&stream->lock);
@@ -3707,6 +3689,8 @@ int consumer_data_pending(uint64_t id)
 				relayd->relayd_session_id, &is_data_inflight);
 		pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
 		if (ret < 0) {
+			ERR("Relayd end data pending failed. Cleaning up relayd %" PRIu64".", relayd->net_seq_idx);
+			lttng_consumer_cleanup_relayd(relayd);
 			goto data_not_pending;
 		}
 		if (is_data_inflight) {