Run clang-format on the whole tree

[lttng-tools.git] / src / bin / lttng-sessiond / tracker.cpp

diff --git a/src/bin/lttng-sessiond/tracker.cpp b/src/bin/lttng-sessiond/tracker.cpp
index 10f8dd59811a4e99f51d6c5fba025e347c4d7df8..a74e46c2975b9e79fe81566d6f8720c7d7174442 100644 (file)
--- a/src/bin/lttng-sessiond/tracker.cpp
+++ b/src/bin/lttng-sessiond/tracker.cpp
@@ -6,26 +6,28 @@
  *
  */
 
-#include "lttng/tracker.h"
 #include "common/dynamic-array.hpp"
 #include "common/macros.hpp"
+#include "lttng/tracker.h"
 #define _LGPL_SOURCE
-#include <grp.h>
-#include <pwd.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <urcu.h>
-#include <urcu/list.h>
-#include <urcu/rculfhash.h>
-
 #include "tracker.hpp"
+
 #include <common/defaults.hpp>
 #include <common/error.hpp>
 #include <common/hashtable/hashtable.hpp>
 #include <common/hashtable/utils.hpp>
 #include <common/tracker.hpp>
+
 #include <lttng/lttng-error.h>
 
+#include <grp.h>
+#include <pwd.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <urcu.h>
+#include <urcu/list.h>
+#include <urcu/rculfhash.h>
+
 struct process_attr_tracker {
        enum lttng_tracking_policy policy;
        struct cds_lfht *inclusion_set_ht;
@@ -41,8 +43,8 @@ struct process_attr_tracker_value_node {
 
 static void process_attr_tracker_value_node_rcu_free(struct rcu_head *rcu_head)
 {
-       struct process_attr_tracker_value_node *node = lttng::utils::container_of(
-                       rcu_head, &process_attr_tracker_value_node::rcu_head);
+       struct process_attr_tracker_value_node *node =
+               lttng::utils::container_of(rcu_head, &process_attr_tracker_value_node::rcu_head);
 
        free(node);
 }
@@ -56,11 +58,10 @@ struct process_attr_tracker *process_attr_tracker_create(void)
                return NULL;
        }
 
-       (void) process_attr_tracker_set_tracking_policy(
-                       tracker, LTTNG_TRACKING_POLICY_INCLUDE_ALL);
+       (void) process_attr_tracker_set_tracking_policy(tracker, LTTNG_TRACKING_POLICY_INCLUDE_ALL);
 
-       tracker->inclusion_set_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
-                       CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
+       tracker->inclusion_set_ht = cds_lfht_new(
+               DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
        if (!tracker->inclusion_set_ht) {
                goto error;
        }
@@ -71,19 +72,16 @@ error:
        return NULL;
 }
 
-static void process_attr_tracker_remove_value_node(
-               struct process_attr_tracker *tracker,
-               struct process_attr_tracker_value_node *value_node)
+static void
+process_attr_tracker_remove_value_node(struct process_attr_tracker *tracker,
+                                      struct process_attr_tracker_value_node *value_node)
 {
-       cds_lfht_del(tracker->inclusion_set_ht,
-                       &value_node->inclusion_set_ht_node);
+       cds_lfht_del(tracker->inclusion_set_ht, &value_node->inclusion_set_ht_node);
        process_attr_value_destroy(value_node->value);
-       call_rcu(&value_node->rcu_head,
-                       process_attr_tracker_value_node_rcu_free);
+       call_rcu(&value_node->rcu_head, process_attr_tracker_value_node_rcu_free);
 }
 
-static void process_attr_tracker_clear_inclusion_set(
-               struct process_attr_tracker *tracker)
+static void process_attr_tracker_clear_inclusion_set(struct process_attr_tracker *tracker)
 {
        int ret;
        struct lttng_ht_iter iter;
@@ -94,8 +92,8 @@ static void process_attr_tracker_clear_inclusion_set(
        }
 
        rcu_read_lock();
-       cds_lfht_for_each_entry (tracker->inclusion_set_ht, &iter.iter,
-                       value_node, inclusion_set_ht_node) {
+       cds_lfht_for_each_entry (
+               tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
                process_attr_tracker_remove_value_node(tracker, value_node);
        }
        rcu_read_unlock();
@@ -104,12 +102,11 @@ static void process_attr_tracker_clear_inclusion_set(
        tracker->inclusion_set_ht = NULL;
 }
 
-static int process_attr_tracker_create_inclusion_set(
-               struct process_attr_tracker *tracker)
+static int process_attr_tracker_create_inclusion_set(struct process_attr_tracker *tracker)
 {
        LTTNG_ASSERT(!tracker->inclusion_set_ht);
-       tracker->inclusion_set_ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
-                       CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
+       tracker->inclusion_set_ht = cds_lfht_new(
+               DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
        return tracker->inclusion_set_ht ? 0 : -1;
 }
 
@@ -123,15 +120,14 @@ void process_attr_tracker_destroy(struct process_attr_tracker *tracker)
        free(tracker);
 }
 
-enum lttng_tracking_policy process_attr_tracker_get_tracking_policy(
-               const struct process_attr_tracker *tracker)
+enum lttng_tracking_policy
+process_attr_tracker_get_tracking_policy(const struct process_attr_tracker *tracker)
 {
        return tracker->policy;
 }
 
-int process_attr_tracker_set_tracking_policy(
-               struct process_attr_tracker *tracker,
-               enum lttng_tracking_policy tracking_policy)
+int process_attr_tracker_set_tracking_policy(struct process_attr_tracker *tracker,
+                                            enum lttng_tracking_policy tracking_policy)
 {
        int ret = 0;
 
@@ -149,21 +145,18 @@ end:
        return ret;
 }
 
-static int match_inclusion_set_value(
-               struct cds_lfht_node *node, const void *key)
+static int match_inclusion_set_value(struct cds_lfht_node *node, const void *key)
 {
        const struct process_attr_value *value_key = (process_attr_value *) key;
-       const struct process_attr_tracker_value_node *value_node =
-                       caa_container_of(node,
-                                       struct process_attr_tracker_value_node,
-                                       inclusion_set_ht_node);
+       const struct process_attr_tracker_value_node *value_node = caa_container_of(
+               node, struct process_attr_tracker_value_node, inclusion_set_ht_node);
 
        return process_attr_tracker_value_equal(value_node->value, value_key);
 }
 
-static struct process_attr_tracker_value_node *process_attr_tracker_lookup(
-               const struct process_attr_tracker *tracker,
-               const struct process_attr_value *value)
+static struct process_attr_tracker_value_node *
+process_attr_tracker_lookup(const struct process_attr_tracker *tracker,
+                           const struct process_attr_value *value)
 {
        struct cds_lfht_iter iter;
        struct cds_lfht_node *node;
@@ -173,22 +166,23 @@ static struct process_attr_tracker_value_node *process_attr_tracker_lookup(
        rcu_read_lock();
        cds_lfht_lookup(tracker->inclusion_set_ht,
                        process_attr_value_hash(value),
-                       match_inclusion_set_value, value, &iter);
+                       match_inclusion_set_value,
+                       value,
+                       &iter);
        node = cds_lfht_iter_get_node(&iter);
        rcu_read_unlock();
 
-       return node ? lttng::utils::container_of(node,
-                                     &process_attr_tracker_value_node::inclusion_set_ht_node) :
-                           NULL;
+       return node ? lttng::utils::container_of(
+                             node, &process_attr_tracker_value_node::inclusion_set_ht_node) :
+                     NULL;
 }
 
 /* Protected by session mutex held by caller. */
-enum process_attr_tracker_status process_attr_tracker_inclusion_set_add_value(
-               struct process_attr_tracker *tracker,
-               const struct process_attr_value *value)
+enum process_attr_tracker_status
+process_attr_tracker_inclusion_set_add_value(struct process_attr_tracker *tracker,
+                                            const struct process_attr_value *value)
 {
-       enum process_attr_tracker_status status =
-                       PROCESS_ATTR_TRACKER_STATUS_OK;
+       enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
        struct process_attr_value *value_copy = NULL;
        struct process_attr_tracker_value_node *value_node = NULL;
 
@@ -217,8 +211,8 @@ enum process_attr_tracker_status process_attr_tracker_inclusion_set_add_value(
 
        value_node->value = value_copy;
        cds_lfht_add(tracker->inclusion_set_ht,
-                       process_attr_value_hash(value_copy),
-                       &value_node->inclusion_set_ht_node);
+                    process_attr_value_hash(value_copy),
+                    &value_node->inclusion_set_ht_node);
        value_copy = NULL;
        value_node = NULL;
 end:
@@ -234,13 +228,11 @@ end:
 
 /* Protected by session mutex held by caller. */
 enum process_attr_tracker_status
-process_attr_tracker_inclusion_set_remove_value(
-               struct process_attr_tracker *tracker,
-               const struct process_attr_value *value)
+process_attr_tracker_inclusion_set_remove_value(struct process_attr_tracker *tracker,
+                                               const struct process_attr_value *value)
 {
        struct process_attr_tracker_value_node *value_node;
-       enum process_attr_tracker_status status =
-                       PROCESS_ATTR_TRACKER_STATUS_OK;
+       enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
 
        rcu_read_lock();
        if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
@@ -260,14 +252,13 @@ end:
        return status;
 }
 
-enum process_attr_tracker_status process_attr_tracker_get_inclusion_set(
-               const struct process_attr_tracker *tracker,
-               struct lttng_process_attr_values **_values)
+enum process_attr_tracker_status
+process_attr_tracker_get_inclusion_set(const struct process_attr_tracker *tracker,
+                                      struct lttng_process_attr_values **_values)
 {
        struct lttng_ht_iter iter;
        struct process_attr_tracker_value_node *value_node;
-       enum process_attr_tracker_status status =
-                       PROCESS_ATTR_TRACKER_STATUS_OK;
+       enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
        struct lttng_process_attr_values *values;
        struct process_attr_value *new_value = NULL;
 
@@ -283,8 +274,8 @@ enum process_attr_tracker_status process_attr_tracker_get_inclusion_set(
        }
 
        rcu_read_lock();
-       cds_lfht_for_each_entry (tracker->inclusion_set_ht, &iter.iter,
-                       value_node, inclusion_set_ht_node) {
+       cds_lfht_for_each_entry (
+               tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
                int ret;
 
                new_value = process_attr_value_copy(value_node->value);
@@ -293,8 +284,7 @@ enum process_attr_tracker_status process_attr_tracker_get_inclusion_set(
                        goto error_unlock;
                }
 
-               ret = lttng_dynamic_pointer_array_add_pointer(
-                               &values->array, new_value);
+               ret = lttng_dynamic_pointer_array_add_pointer(&values->array, new_value);
                if (ret) {
                        status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
                        goto error_unlock;