Merge duplicate code in consumer for destroy relayd
authorDavid Goulet <dgoulet@efficios.com>
Mon, 20 Aug 2012 21:12:51 +0000 (17:12 -0400)
committerDavid Goulet <dgoulet@efficios.com>
Mon, 20 Aug 2012 21:12:51 +0000 (17:12 -0400)
Kernel and UST were using the same exact code for the DESTROY_RELAYD
command received from the session daemon.

Signed-off-by: David Goulet <dgoulet@efficios.com>
src/common/consumer.c
src/common/consumer.h
src/common/kernel-consumer/kernel-consumer.c
src/common/ust-consumer/ust-consumer.c

index 363fa4eda6c5ba0dc75296d4c9f7d764c80b21da..2ee6c331318a844f675013b691a30e4fc34079f5 100644 (file)
@@ -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.
index da3c4ce5a69b75c8eafc5bb9eeefa4cba2778026..fc5d5ef14dfdf02a1dbb62f63b46c76fa22c1150 100644 (file)
@@ -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 */
index 86ccddfd09e80672fbca3fb1ab6f772fb41bcc81..4a7ba04516e442aae6b824d61923bffd1f652e1c 100644 (file)
@@ -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:
index a8872aaf33481239df05e39c5b6c29851cd83586..9cafe398e1493be918896b8bc803c14e0f98e242 100644 (file)
@@ -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:
This page took 0.042097 seconds and 4 git commands to generate.