Clean-up: modernize pretty_xml.cpp

[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 a74e46c2975b9e79fe81566d6f8720c7d7174442..526e51b6bc847ad47f7b4ceec872f95c975cbba7 100644 (file)
--- a/src/bin/lttng-sessiond/tracker.cpp
+++ b/src/bin/lttng-sessiond/tracker.cpp
@@ -17,6 +17,7 @@
 #include <common/hashtable/hashtable.hpp>
 #include <common/hashtable/utils.hpp>
 #include <common/tracker.hpp>
+#include <common/urcu.hpp>
 
 #include <lttng/lttng-error.h>
 
@@ -49,19 +50,19 @@ static void process_attr_tracker_value_node_rcu_free(struct rcu_head *rcu_head)
        free(node);
 }
 
-struct process_attr_tracker *process_attr_tracker_create(void)
+struct process_attr_tracker *process_attr_tracker_create()
 {
        struct process_attr_tracker *tracker;
 
        tracker = zmalloc<process_attr_tracker>();
        if (!tracker) {
-               return NULL;
+               return nullptr;
        }
 
        (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);
+               DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, nullptr);
        if (!tracker->inclusion_set_ht) {
                goto error;
        }
@@ -69,7 +70,7 @@ struct process_attr_tracker *process_attr_tracker_create(void)
        return tracker;
 error:
        process_attr_tracker_destroy(tracker);
-       return NULL;
+       return nullptr;
 }
 
 static void
@@ -91,22 +92,25 @@ static void process_attr_tracker_clear_inclusion_set(struct process_attr_tracker
                return;
        }
 
-       rcu_read_lock();
-       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);
+       {
+               lttng::urcu::read_lock_guard read_lock;
+
+               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();
-       ret = cds_lfht_destroy(tracker->inclusion_set_ht, NULL);
+
+       ret = cds_lfht_destroy(tracker->inclusion_set_ht, nullptr);
        LTTNG_ASSERT(ret == 0);
-       tracker->inclusion_set_ht = NULL;
+       tracker->inclusion_set_ht = nullptr;
 }
 
 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);
+               DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, nullptr);
        return tracker->inclusion_set_ht ? 0 : -1;
 }
 
@@ -163,18 +167,17 @@ process_attr_tracker_lookup(const struct process_attr_tracker *tracker,
 
        LTTNG_ASSERT(tracker->policy == LTTNG_TRACKING_POLICY_INCLUDE_SET);
 
-       rcu_read_lock();
+       lttng::urcu::read_lock_guard read_lock;
        cds_lfht_lookup(tracker->inclusion_set_ht,
                        process_attr_value_hash(value),
                        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;
+                     nullptr;
 }
 
 /* Protected by session mutex held by caller. */
@@ -183,10 +186,10 @@ process_attr_tracker_inclusion_set_add_value(struct process_attr_tracker *tracke
                                             const struct process_attr_value *value)
 {
        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;
+       struct process_attr_value *value_copy = nullptr;
+       struct process_attr_tracker_value_node *value_node = nullptr;
 
-       rcu_read_lock();
+       lttng::urcu::read_lock_guard read_lock;
        if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
                status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
                goto end;
@@ -213,8 +216,8 @@ process_attr_tracker_inclusion_set_add_value(struct process_attr_tracker *tracke
        cds_lfht_add(tracker->inclusion_set_ht,
                     process_attr_value_hash(value_copy),
                     &value_node->inclusion_set_ht_node);
-       value_copy = NULL;
-       value_node = NULL;
+       value_copy = nullptr;
+       value_node = nullptr;
 end:
        if (value_copy) {
                process_attr_value_destroy(value_copy);
@@ -222,7 +225,6 @@ end:
        if (value_node) {
                free(value_node);
        }
-       rcu_read_unlock();
        return status;
 }
 
@@ -234,7 +236,7 @@ process_attr_tracker_inclusion_set_remove_value(struct process_attr_tracker *tra
        struct process_attr_tracker_value_node *value_node;
        enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
 
-       rcu_read_lock();
+       lttng::urcu::read_lock_guard read_lock;
        if (tracker->policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
                status = PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY;
                goto end;
@@ -248,7 +250,6 @@ process_attr_tracker_inclusion_set_remove_value(struct process_attr_tracker *tra
 
        process_attr_tracker_remove_value_node(tracker, value_node);
 end:
-       rcu_read_unlock();
        return status;
 }
 
@@ -260,7 +261,7 @@ process_attr_tracker_get_inclusion_set(const struct process_attr_tracker *tracke
        struct process_attr_tracker_value_node *value_node;
        enum process_attr_tracker_status status = PROCESS_ATTR_TRACKER_STATUS_OK;
        struct lttng_process_attr_values *values;
-       struct process_attr_value *new_value = NULL;
+       struct process_attr_value *new_value = nullptr;
 
        values = lttng_process_attr_values_create();
        if (!values) {
@@ -273,30 +274,32 @@ process_attr_tracker_get_inclusion_set(const struct process_attr_tracker *tracke
                goto error;
        }
 
-       rcu_read_lock();
-       cds_lfht_for_each_entry (
-               tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
-               int ret;
+       {
+               lttng::urcu::read_lock_guard read_lock;
 
-               new_value = process_attr_value_copy(value_node->value);
-               if (!new_value) {
-                       status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
-                       goto error_unlock;
-               }
+               cds_lfht_for_each_entry (
+                       tracker->inclusion_set_ht, &iter.iter, value_node, inclusion_set_ht_node) {
+                       int ret;
 
-               ret = lttng_dynamic_pointer_array_add_pointer(&values->array, new_value);
-               if (ret) {
-                       status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
-                       goto error_unlock;
-               }
+                       new_value = process_attr_value_copy(value_node->value);
+                       if (!new_value) {
+                               status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
+                               goto error_unlock;
+                       }
+
+                       ret = lttng_dynamic_pointer_array_add_pointer(&values->array, new_value);
+                       if (ret) {
+                               status = PROCESS_ATTR_TRACKER_STATUS_ERROR;
+                               goto error_unlock;
+                       }
 
-               new_value = NULL;
+                       new_value = nullptr;
+               }
        }
-       rcu_read_unlock();
+
        *_values = values;
        return status;
 error_unlock:
-       rcu_read_unlock();
 error:
        lttng_process_attr_values_destroy(values);
        process_attr_value_destroy(new_value);