From a6ba4fe1a8217fd5cb9e286b4d88a9252c0d5d06 Mon Sep 17 00:00:00 2001 From: David Goulet Date: Mon, 20 Aug 2012 17:12:51 -0400 Subject: [PATCH] Merge duplicate code in consumer for destroy relayd Kernel and UST were using the same exact code for the DESTROY_RELAYD command received from the session daemon. Signed-off-by: David Goulet --- src/common/consumer.c | 19 ++++++++++++++ src/common/consumer.h | 2 ++ src/common/kernel-consumer/kernel-consumer.c | 26 +++++++++++--------- src/common/ust-consumer/ust-consumer.c | 25 +++++++++++-------- 4 files changed, 51 insertions(+), 21 deletions(-) diff --git a/src/common/consumer.c b/src/common/consumer.c index 363fa4eda..2ee6c3313 100644 --- a/src/common/consumer.c +++ b/src/common/consumer.c @@ -201,6 +201,25 @@ void consumer_destroy_relayd(struct consumer_relayd_sock_pair *relayd) call_rcu(&relayd->node.head, consumer_rcu_free_relayd); } +/* + * Flag a relayd socket pair for destruction. Destroy it if the refcount + * reaches zero. + * + * RCU read side lock MUST be aquired before calling this function. + */ +void consumer_flag_relayd_for_destroy(struct consumer_relayd_sock_pair *relayd) +{ + assert(relayd); + + /* Set destroy flag for this object */ + uatomic_set(&relayd->destroy_flag, 1); + + /* Destroy the relayd if refcount is 0 */ + if (uatomic_read(&relayd->refcount) == 0) { + consumer_destroy_relayd(relayd); + } +} + /* * Remove a stream from the global list protected by a mutex. This * function is also responsible for freeing its data structures. diff --git a/src/common/consumer.h b/src/common/consumer.h index da3c4ce5a..fc5d5ef14 100644 --- a/src/common/consumer.h +++ b/src/common/consumer.h @@ -384,5 +384,7 @@ int lttng_consumer_on_recv_stream(struct lttng_consumer_stream *stream); int consumer_add_relayd_socket(int net_seq_idx, int sock_type, struct lttng_consumer_local_data *ctx, int sock, struct pollfd *consumer_sockpoll, struct lttcomm_sock *relayd_sock); +void consumer_flag_relayd_for_destroy( + struct consumer_relayd_sock_pair *relayd); #endif /* LIB_CONSUMER_H */ diff --git a/src/common/kernel-consumer/kernel-consumer.c b/src/common/kernel-consumer/kernel-consumer.c index 86ccddfd0..4a7ba0451 100644 --- a/src/common/kernel-consumer/kernel-consumer.c +++ b/src/common/kernel-consumer/kernel-consumer.c @@ -211,26 +211,30 @@ int lttng_kconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, } case LTTNG_CONSUMER_DESTROY_RELAYD: { + uint64_t index = msg.u.destroy_relayd.net_seq_idx; struct consumer_relayd_sock_pair *relayd; - DBG("Kernel consumer destroying relayd %" PRIu64, - msg.u.destroy_relayd.net_seq_idx); + DBG("Kernel consumer destroying relayd %" PRIu64, index); /* Get relayd reference if exists. */ - relayd = consumer_find_relayd(msg.u.destroy_relayd.net_seq_idx); + relayd = consumer_find_relayd(index); if (relayd == NULL) { - ERR("Unable to find relayd %" PRIu64, - msg.u.destroy_relayd.net_seq_idx); + ERR("Unable to find relayd %" PRIu64, index); goto end_nosignal; } - /* Set destroy flag for this object */ - uatomic_set(&relayd->destroy_flag, 1); + /* + * Each relayd socket pair has a refcount of stream attached to it + * which tells if the relayd is still active or not depending on the + * refcount value. + * + * This will set the destroy flag of the relayd object and destroy it + * if the refcount reaches zero when called. + * + * The destroy can happen either here or when a stream fd hangs up. + */ + consumer_flag_relayd_for_destroy(relayd); - /* Destroy the relayd if refcount is 0 else set the destroy flag. */ - if (uatomic_read(&relayd->refcount) == 0) { - consumer_destroy_relayd(relayd); - } goto end_nosignal; } default: diff --git a/src/common/ust-consumer/ust-consumer.c b/src/common/ust-consumer/ust-consumer.c index a8872aaf3..9cafe398e 100644 --- a/src/common/ust-consumer/ust-consumer.c +++ b/src/common/ust-consumer/ust-consumer.c @@ -241,25 +241,30 @@ int lttng_ustconsumer_recv_cmd(struct lttng_consumer_local_data *ctx, } case LTTNG_CONSUMER_DESTROY_RELAYD: { + uint64_t index = msg.u.destroy_relayd.net_seq_idx; struct consumer_relayd_sock_pair *relayd; - DBG("UST consumer destroying relayd %" PRIu64, - msg.u.destroy_relayd.net_seq_idx); + DBG("UST consumer destroying relayd %" PRIu64, index); /* Get relayd reference if exists. */ - relayd = consumer_find_relayd(msg.u.destroy_relayd.net_seq_idx); + relayd = consumer_find_relayd(index); if (relayd == NULL) { - ERR("Unable to find relayd %" PRIu64, msg.u.destroy_relayd.net_seq_idx); + ERR("Unable to find relayd %" PRIu64, index); goto end_nosignal; } - /* Set destroy flag for this object */ - uatomic_set(&relayd->destroy_flag, 1); + /* + * Each relayd socket pair has a refcount of stream attached to it + * which tells if the relayd is still active or not depending on the + * refcount value. + * + * This will set the destroy flag of the relayd object and destroy it + * if the refcount reaches zero when called. + * + * The destroy can happen either here or when a stream fd hangs up. + */ + consumer_flag_relayd_for_destroy(relayd); - /* Destroy the relayd if refcount is 0 else set the destroy flag. */ - if (uatomic_read(&relayd->refcount) == 0) { - consumer_destroy_relayd(relayd); - } goto end_nosignal; } case LTTNG_CONSUMER_UPDATE_STREAM: -- 2.34.1