Run clang-format on the whole tree

[lttng-tools.git] / src / lib / lttng-ctl / tracker.cpp

diff --git a/src/lib/lttng-ctl/tracker.cpp b/src/lib/lttng-ctl/tracker.cpp
index 47d8ecb5cf1e1e123173222c49b8f893efaf08a1..cf32a4c33d8f80f7e48f2c7a020dbbfd41b42e62 100644 (file)
--- a/src/lib/lttng-ctl/tracker.cpp
+++ b/src/lib/lttng-ctl/tracker.cpp
@@ -5,13 +5,15 @@
  *
  */
 
  *
  */
 

-#include <lttng/domain.h>
-#include <lttng/lttng-error.h>
-

 #include "lttng-ctl-helper.hpp"
 #include "lttng-ctl-helper.hpp"

+

 #include <common/sessiond-comm/sessiond-comm.hpp>
 #include <common/tracker.hpp>
 #include <common/sessiond-comm/sessiond-comm.hpp>
 #include <common/tracker.hpp>

+
+#include <lttng/domain.h>
+#include <lttng/lttng-error.h>

 #include <lttng/tracker.h>
 #include <lttng/tracker.h>

+

 #include <type_traits>
 
 struct lttng_process_attr_tracker_handle {
 #include <type_traits>
 
 struct lttng_process_attr_tracker_handle {


@@ -21,8 +23,7 @@ struct lttng_process_attr_tracker_handle {
        struct lttng_process_attr_values *inclusion_set;
 };
 
        struct lttng_process_attr_values *inclusion_set;
 };
 

-void lttng_process_attr_tracker_handle_destroy(
-               struct lttng_process_attr_tracker_handle *tracker)
+void lttng_process_attr_tracker_handle_destroy(struct lttng_process_attr_tracker_handle *tracker)

 {
        if (!tracker) {
                return;
 {
        if (!tracker) {
                return;


@@ -33,10 +34,11 @@ void lttng_process_attr_tracker_handle_destroy(
        free(tracker);
 }
 
        free(tracker);
 }
 

-enum lttng_error_code lttng_session_get_tracker_handle(const char *session_name,
-               enum lttng_domain_type domain,
-               enum lttng_process_attr process_attr,
-               struct lttng_process_attr_tracker_handle **out_tracker_handle)
+enum lttng_error_code
+lttng_session_get_tracker_handle(const char *session_name,
+                                enum lttng_domain_type domain,
+                                enum lttng_process_attr process_attr,
+                                struct lttng_process_attr_tracker_handle **out_tracker_handle)

 {
        enum lttng_error_code ret_code = LTTNG_OK;
        struct lttng_process_attr_tracker_handle *handle = NULL;
 {
        enum lttng_error_code ret_code = LTTNG_OK;
        struct lttng_process_attr_tracker_handle *handle = NULL;


@@ -72,8 +74,7 @@ enum lttng_error_code lttng_session_get_tracker_handle(const char *session_name,
         * Use the `get_tracking_policy` command to validate the tracker's
         * existence.
         */
         * Use the `get_tracking_policy` command to validate the tracker's
         * existence.
         */

-       status = lttng_process_attr_tracker_handle_get_tracking_policy(
-                       handle, &policy);
+       status = lttng_process_attr_tracker_handle_get_tracking_policy(handle, &policy);

        switch (status) {
        case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK:
                break;
        switch (status) {
        case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK:
                break;


@@ -92,15 +93,13 @@ error:
        return ret_code;
 }
 
        return ret_code;
 }
 

-enum lttng_process_attr_tracker_handle_status
-lttng_process_attr_tracker_handle_get_tracking_policy(
-               const struct lttng_process_attr_tracker_handle *tracker,
-               enum lttng_tracking_policy *policy)
+enum lttng_process_attr_tracker_handle_status lttng_process_attr_tracker_handle_get_tracking_policy(
+       const struct lttng_process_attr_tracker_handle *tracker, enum lttng_tracking_policy *policy)

 {
        void *reply = NULL;
        int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =
 {
        void *reply = NULL;
        int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =

-                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;
+               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;

        struct lttcomm_session_msg lsm = {
                .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_POLICY,
                .session = {},
        struct lttcomm_session_msg lsm = {
                .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_POLICY,
                .session = {},


@@ -114,8 +113,7 @@ lttng_process_attr_tracker_handle_get_tracking_policy(
                goto end;
        }
 
                goto end;
        }
 

-       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name,
-                       sizeof(lsm.session.name));
+       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name, sizeof(lsm.session.name));

        if (copy_ret) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
                goto end;
        if (copy_ret) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
                goto end;


@@ -123,14 +121,13 @@ lttng_process_attr_tracker_handle_get_tracking_policy(
 
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_get_tracking_policy.process_attr =
 
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_get_tracking_policy.process_attr =

-                       (int32_t) tracker->process_attr;
+               (int32_t) tracker->process_attr;

 
        /* Command returns a session descriptor on success. */
 
        /* Command returns a session descriptor on success. */

-       reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(
-                       &lsm, NULL, 0, &reply);
+       reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, NULL, 0, &reply);

        if (reply_ret != sizeof(uint32_t)) {
                if (reply_ret == -LTTNG_ERR_SESSION_NOT_EXIST ||
        if (reply_ret != sizeof(uint32_t)) {
                if (reply_ret == -LTTNG_ERR_SESSION_NOT_EXIST ||

-                               reply_ret == -LTTNG_ERR_SESS_NOT_FOUND) {
+                   reply_ret == -LTTNG_ERR_SESS_NOT_FOUND) {

                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST;
                } else {
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST;
                } else {
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;


@@ -144,14 +141,12 @@ end:
        return status;
 }
 
        return status;
 }
 

-enum lttng_process_attr_tracker_handle_status
-lttng_process_attr_tracker_handle_set_tracking_policy(
-               const struct lttng_process_attr_tracker_handle *tracker,
-               enum lttng_tracking_policy policy)
+enum lttng_process_attr_tracker_handle_status lttng_process_attr_tracker_handle_set_tracking_policy(
+       const struct lttng_process_attr_tracker_handle *tracker, enum lttng_tracking_policy policy)

 {
        int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =
 {
        int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =

-                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;
+               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;

        struct lttcomm_session_msg lsm = {
                .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY,
                .session = {},
        struct lttcomm_session_msg lsm = {
                .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY,
                .session = {},


@@ -165,8 +160,7 @@ lttng_process_attr_tracker_handle_set_tracking_policy(
                goto end;
        }
 
                goto end;
        }
 

-       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name,
-                                sizeof(lsm.session.name));
+       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name, sizeof(lsm.session.name));

        if (copy_ret) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
                goto end;
        if (copy_ret) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
                goto end;


@@ -174,9 +168,8 @@ lttng_process_attr_tracker_handle_set_tracking_policy(
 
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_set_tracking_policy.process_attr =
 
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_set_tracking_policy.process_attr =

-                       (int32_t) tracker->process_attr;
-       lsm.u.process_attr_tracker_set_tracking_policy.tracking_policy =
-                       (int32_t) policy;
+               (int32_t) tracker->process_attr;
+       lsm.u.process_attr_tracker_set_tracking_policy.tracking_policy = (int32_t) policy;

 
        /* Command returns a session descriptor on success. */
        reply_ret = lttng_ctl_ask_sessiond(&lsm, NULL);
 
        /* Command returns a session descriptor on success. */
        reply_ret = lttng_ctl_ask_sessiond(&lsm, NULL);


@@ -192,205 +185,183 @@ end:
        return status;
 }
 
        return status;
 }
 

-#define DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(command_upper,                                                 \
-               command_lower, process_attr_name, value_type_name,                                                   \
-               value_type_c, value_type_enum)                                                                       \
-       enum lttng_process_attr_tracker_handle_status                                                                \
-                       lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name( \
-                                       const struct lttng_process_attr_tracker_handle                               \
-                                                       *tracker,                                                    \
-                                       value_type_c value)                                                          \
-       {                                                                                                            \
-               int ret;                                                                                             \
-               enum lttng_process_attr_tracker_handle_status status =                                               \
-                               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;                                         \
-               struct lttcomm_session_msg lsm = {                                                                   \
-                       .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE,                      \
-                       .session = {},                                                                               \
-                       .domain = {},                                                                                \
-                       .u = {},                                                                                     \
-                       .fd_count = 0,                                                                               \
-               };                                                                                                   \
-                                                                                                                     \
-               if (!tracker) {                                                                                      \
-                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                                   \
-                       goto end;                                                                                    \
-               }                                                                                                    \
-                                                                                                                     \
-               ret = lttng_strncpy(lsm.session.name, tracker->session_name,                                         \
-                               sizeof(lsm.session.name));                                                           \
-               if (ret) {                                                                                           \
-                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                                   \
-                       goto end;                                                                                    \
-               }                                                                                                    \
-                                                                                                                     \
-               lsm.domain.type = tracker->domain;                                                                   \
-               lsm.u.process_attr_tracker_add_remove_include_value                                                  \
-                               .process_attr =                                                                      \
-                               (int32_t) tracker->process_attr;                                                     \
-               lsm.u.process_attr_tracker_add_remove_include_value                                                  \
-                               .value_type = (uint32_t)                                                             \
-                               LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum;                                     \
-                                                                                                                     \
-               if (std::is_signed<value_type_c>::value) {                                                                       \
-                       lsm.u.process_attr_tracker_add_remove_include_value                                          \
-                                       .integral_value.u._signed = value;                                           \
-               } else {                                                                                             \
-                       lsm.u.process_attr_tracker_add_remove_include_value                                          \
-                                       .integral_value.u._unsigned = value;                                         \
-               }                                                                                                    \
-                                                                                                                     \
-               ret = lttng_ctl_ask_sessiond(&lsm, NULL);                                                            \
-               if (ret < 0) {                                                                                       \
-                       switch (-ret) {                                                                              \
-                       case LTTNG_ERR_PROCESS_ATTR_EXISTS:                                                          \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS;                            \
-                               break;                                                                               \
-                       case LTTNG_ERR_PROCESS_ATTR_MISSING:                                                         \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING;                           \
-                               break;                                                                               \
-                       case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY:                                 \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY;           \
-                               break;                                                                               \
-                       default:                                                                                     \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;                             \
-                       }                                                                                            \
-               }                                                                                                    \
-       end:                                                                                                         \
-               return status;                                                                                       \
-       }
-
-#define DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(command_upper,                                                   \
-               command_lower, process_attr_name, value_type_name,                                                   \
-               value_type_enum)                                                                                     \
-       enum lttng_process_attr_tracker_handle_status                                                                \
-                       lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name( \
-                                       const struct lttng_process_attr_tracker_handle                               \
-                                                       *tracker,                                                    \
-                                       const char *value)                                                           \
-       {                                                                                                            \
-               int ret;                                                                                             \
-               enum lttng_process_attr_tracker_handle_status status =                                               \
-                               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;                                         \
-               struct lttcomm_session_msg lsm = {                                                                   \
-                       .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE,                      \
-                       .session = {},                                                                               \
-                       .domain = {},                                                                                \
-                       .u = {},                                                                                     \
-                       .fd_count = 0,                                                                               \
-               };                                                                                                   \
-               const size_t len = value ? strlen(value) + 1 : 0;                                                    \
-                                                                                                                     \
-               if (!tracker || !value) {                                                                            \
-                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                                   \
-                       goto end;                                                                                    \
-               }                                                                                                    \
-                                                                                                                     \
-               ret = lttng_strncpy(lsm.session.name, tracker->session_name,                                         \
-                               sizeof(lsm.session.name));                                                           \
-               if (ret) {                                                                                           \
-                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                                   \
-                       goto end;                                                                                    \
-               }                                                                                                    \
-                                                                                                                     \
-               lsm.domain.type = tracker->domain;                                                                   \
-               lsm.u.process_attr_tracker_add_remove_include_value                                                  \
-                               .process_attr =                                                                      \
-                               (int32_t) tracker->process_attr;                                                     \
-               lsm.u.process_attr_tracker_add_remove_include_value.name_len =                                       \
-                               (uint32_t) len;                                                                      \
-               lsm.u.process_attr_tracker_add_remove_include_value                                                  \
-                               .value_type = (uint32_t)                                                             \
-                               LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum;                                     \
-                                                                                                                     \
-               ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(                                                   \
-                               &lsm, value, len, NULL);                                                             \
-               if (ret < 0) {                                                                                       \
-                       switch (-ret) {                                                                              \
-                       case LTTNG_ERR_PROCESS_ATTR_EXISTS:                                                          \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS;                            \
-                               break;                                                                               \
-                       case LTTNG_ERR_PROCESS_ATTR_MISSING:                                                         \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING;                           \
-                               break;                                                                               \
-                       case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY:                                 \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY;           \
-                               break;                                                                               \
-                       case LTTNG_ERR_USER_NOT_FOUND:                                                               \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_USER_NOT_FOUND;                    \
-                               break;                                                                               \
-                       case LTTNG_ERR_GROUP_NOT_FOUND:                                                              \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_GROUP_NOT_FOUND;                   \
-                               break;                                                                               \
-                       default:                                                                                     \
-                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;                             \
-                       }                                                                                            \
-               }                                                                                                    \
-       end:                                                                                                         \
-               return status;                                                                                       \
+#define DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(command_upper,                                           \
+                                                     command_lower,                                           \
+                                                     process_attr_name,                                       \
+                                                     value_type_name,                                         \
+                                                     value_type_c,                                            \
+                                                     value_type_enum)                                         \
+       enum lttng_process_attr_tracker_handle_status                                                          \
+               lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name(   \
+                       const struct lttng_process_attr_tracker_handle *tracker,                               \
+                       value_type_c value)                                                                    \
+       {                                                                                                      \
+               int ret;                                                                                       \
+               enum lttng_process_attr_tracker_handle_status status =                                         \
+                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;                                           \
+               struct lttcomm_session_msg lsm = {                                                             \
+                       .cmd_type =                                                                            \
+                               LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE, \
+                       .session = {},                                                                         \
+                       .domain = {},                                                                          \
+                       .u = {},                                                                               \
+                       .fd_count = 0,                                                                         \
+               };                                                                                             \
+                                                                                                               \
+               if (!tracker) {                                                                                \
+                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                             \
+                       goto end;                                                                              \
+               }                                                                                              \
+                                                                                                               \
+               ret = lttng_strncpy(                                                                           \
+                       lsm.session.name, tracker->session_name, sizeof(lsm.session.name));                    \
+               if (ret) {                                                                                     \
+                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                             \
+                       goto end;                                                                              \
+               }                                                                                              \
+                                                                                                               \
+               lsm.domain.type = tracker->domain;                                                             \
+               lsm.u.process_attr_tracker_add_remove_include_value.process_attr =                             \
+                       (int32_t) tracker->process_attr;                                                       \
+               lsm.u.process_attr_tracker_add_remove_include_value.value_type =                               \
+                       (uint32_t) LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum;                            \
+                                                                                                               \
+               if (std::is_signed<value_type_c>::value) {                                                     \
+                       lsm.u.process_attr_tracker_add_remove_include_value.integral_value.u                   \
+                               ._signed = value;                                                              \
+               } else {                                                                                       \
+                       lsm.u.process_attr_tracker_add_remove_include_value.integral_value.u                   \
+                               ._unsigned = value;                                                            \
+               }                                                                                              \
+                                                                                                               \
+               ret = lttng_ctl_ask_sessiond(&lsm, NULL);                                                      \
+               if (ret < 0) {                                                                                 \
+                       switch (-ret) {                                                                        \
+                       case LTTNG_ERR_PROCESS_ATTR_EXISTS:                                                    \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS;                      \
+                               break;                                                                         \
+                       case LTTNG_ERR_PROCESS_ATTR_MISSING:                                                   \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING;                     \
+                               break;                                                                         \
+                       case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY:                           \
+                               status =                                                                       \
+                                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY;      \
+                               break;                                                                         \
+                       default:                                                                               \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;                       \
+                       }                                                                                      \
+               }                                                                                              \
+       end:                                                                                                   \
+               return status;                                                                                 \
+       }
+
+#define DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(                                                           \
+       command_upper, command_lower, process_attr_name, value_type_name, value_type_enum)                     \
+       enum lttng_process_attr_tracker_handle_status                                                          \
+               lttng_process_attr_##process_attr_name##_tracker_handle_##command_lower##_##value_type_name(   \
+                       const struct lttng_process_attr_tracker_handle *tracker,                               \
+                       const char *value)                                                                     \
+       {                                                                                                      \
+               int ret;                                                                                       \
+               enum lttng_process_attr_tracker_handle_status status =                                         \
+                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;                                           \
+               struct lttcomm_session_msg lsm = {                                                             \
+                       .cmd_type =                                                                            \
+                               LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_##command_upper##_INCLUDE_VALUE, \
+                       .session = {},                                                                         \
+                       .domain = {},                                                                          \
+                       .u = {},                                                                               \
+                       .fd_count = 0,                                                                         \
+               };                                                                                             \
+               const size_t len = value ? strlen(value) + 1 : 0;                                              \
+                                                                                                               \
+               if (!tracker || !value) {                                                                      \
+                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                             \
+                       goto end;                                                                              \
+               }                                                                                              \
+                                                                                                               \
+               ret = lttng_strncpy(                                                                           \
+                       lsm.session.name, tracker->session_name, sizeof(lsm.session.name));                    \
+               if (ret) {                                                                                     \
+                       status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;                             \
+                       goto end;                                                                              \
+               }                                                                                              \
+                                                                                                               \
+               lsm.domain.type = tracker->domain;                                                             \
+               lsm.u.process_attr_tracker_add_remove_include_value.process_attr =                             \
+                       (int32_t) tracker->process_attr;                                                       \
+               lsm.u.process_attr_tracker_add_remove_include_value.name_len = (uint32_t) len;                 \
+               lsm.u.process_attr_tracker_add_remove_include_value.value_type =                               \
+                       (uint32_t) LTTNG_PROCESS_ATTR_VALUE_TYPE_##value_type_enum;                            \
+                                                                                                               \
+               ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, value, len, NULL);                     \
+               if (ret < 0) {                                                                                 \
+                       switch (-ret) {                                                                        \
+                       case LTTNG_ERR_PROCESS_ATTR_EXISTS:                                                    \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_EXISTS;                      \
+                               break;                                                                         \
+                       case LTTNG_ERR_PROCESS_ATTR_MISSING:                                                   \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_MISSING;                     \
+                               break;                                                                         \
+                       case LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY:                           \
+                               status =                                                                       \
+                                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY;      \
+                               break;                                                                         \
+                       case LTTNG_ERR_USER_NOT_FOUND:                                                         \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_USER_NOT_FOUND;              \
+                               break;                                                                         \
+                       case LTTNG_ERR_GROUP_NOT_FOUND:                                                        \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_GROUP_NOT_FOUND;             \
+                               break;                                                                         \
+                       default:                                                                               \
+                               status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;                       \
+                       }                                                                                      \
+               }                                                                                              \
+       end:                                                                                                   \
+               return status;                                                                                 \

        }
 
 /* PID */
        }
 
 /* PID */

-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               ADD, add, process_id, pid, pid_t, PID);
-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               REMOVE, remove, process_id, pid, pid_t, PID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(ADD, add, process_id, pid, pid_t, PID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(REMOVE, remove, process_id, pid, pid_t, PID);

 
 /* VPID */
 
 /* VPID */

-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               ADD, add, virtual_process_id, pid, pid_t, PID);
-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               REMOVE, remove, virtual_process_id, pid, pid_t, PID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(ADD, add, virtual_process_id, pid, pid_t, PID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(REMOVE, remove, virtual_process_id, pid, pid_t, PID);

 
 /* UID */
 
 /* UID */

-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               ADD, add, user_id, uid, uid_t, UID);
-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               REMOVE, remove, user_id, uid, uid_t, UID);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               ADD, add, user_id, user_name, USER_NAME);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               REMOVE, remove, user_id, user_name, USER_NAME);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(ADD, add, user_id, uid, uid_t, UID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(REMOVE, remove, user_id, uid, uid_t, UID);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(ADD, add, user_id, user_name, USER_NAME);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(REMOVE, remove, user_id, user_name, USER_NAME);

 
 /* VUID */
 
 /* VUID */

-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               ADD, add, virtual_user_id, uid, uid_t, UID);
-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               REMOVE, remove, virtual_user_id, uid, uid_t, UID);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               ADD, add, virtual_user_id, user_name, USER_NAME);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               REMOVE, remove, virtual_user_id, user_name, USER_NAME);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(ADD, add, virtual_user_id, uid, uid_t, UID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(REMOVE, remove, virtual_user_id, uid, uid_t, UID);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(ADD, add, virtual_user_id, user_name, USER_NAME);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(REMOVE, remove, virtual_user_id, user_name, USER_NAME);

 
 /* GID */
 
 /* GID */

-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               ADD, add, group_id, gid, gid_t, GID);
-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               REMOVE, remove, group_id, gid, gid_t, GID);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               ADD, add, group_id, group_name, GROUP_NAME);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               REMOVE, remove, group_id, group_name, GROUP_NAME);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(ADD, add, group_id, gid, gid_t, GID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(REMOVE, remove, group_id, gid, gid_t, GID);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(ADD, add, group_id, group_name, GROUP_NAME);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(REMOVE, remove, group_id, group_name, GROUP_NAME);

 
 /* VGID */
 
 /* VGID */

-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               ADD, add, virtual_group_id, gid, gid_t, GID);
-DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(
-               REMOVE, remove, virtual_group_id, gid, gid_t, GID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(ADD, add, virtual_group_id, gid, gid_t, GID);
+DEFINE_TRACKER_ADD_REMOVE_INTEGRAL_VALUE_FUNC(REMOVE, remove, virtual_group_id, gid, gid_t, GID);
+DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(ADD, add, virtual_group_id, group_name, GROUP_NAME);

 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
 DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(

-               ADD, add, virtual_group_id, group_name, GROUP_NAME);
-DEFINE_TRACKER_ADD_REMOVE_STRING_VALUE_FUNC(
-               REMOVE, remove, virtual_group_id, group_name, GROUP_NAME);
+       REMOVE, remove, virtual_group_id, group_name, GROUP_NAME);

 
 

-enum lttng_process_attr_tracker_handle_status
-lttng_process_attr_tracker_handle_get_inclusion_set(
-               struct lttng_process_attr_tracker_handle *tracker,
-               const struct lttng_process_attr_values **values)
+enum lttng_process_attr_tracker_handle_status lttng_process_attr_tracker_handle_get_inclusion_set(
+       struct lttng_process_attr_tracker_handle *tracker,
+       const struct lttng_process_attr_values **values)

 {
        char *reply = NULL;
        int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =
 {
        char *reply = NULL;
        int reply_ret, copy_ret;
        enum lttng_process_attr_tracker_handle_status status =

-                       LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;
+               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK;

        struct lttcomm_session_msg lsm = {
                .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET,
                .session = {},
        struct lttcomm_session_msg lsm = {
                .cmd_type = LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET,
                .session = {},


@@ -409,8 +380,7 @@ lttng_process_attr_tracker_handle_get_inclusion_set(
        lttng_process_attr_values_destroy(tracker->inclusion_set);
        tracker->inclusion_set = NULL;
 
        lttng_process_attr_values_destroy(tracker->inclusion_set);
        tracker->inclusion_set = NULL;
 

-       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name,
-                       sizeof(lsm.session.name));
+       copy_ret = lttng_strncpy(lsm.session.name, tracker->session_name, sizeof(lsm.session.name));

        if (copy_ret) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
                goto end;
        if (copy_ret) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID;
                goto end;


@@ -418,16 +388,14 @@ lttng_process_attr_tracker_handle_get_inclusion_set(
 
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_get_tracking_policy.process_attr =
 
        lsm.domain.type = tracker->domain;
        lsm.u.process_attr_tracker_get_tracking_policy.process_attr =

-                       (int32_t) tracker->process_attr;
+               (int32_t) tracker->process_attr;

 
        /* Command returns a session descriptor on success. */
 
        /* Command returns a session descriptor on success. */

-       reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(
-                       &lsm, NULL, 0, (void **) &reply);
+       reply_ret = lttng_ctl_ask_sessiond_varlen_no_cmd_header(&lsm, NULL, 0, (void **) &reply);

        if (reply_ret < 0) {
                if (reply_ret == -LTTNG_ERR_SESSION_NOT_EXIST) {
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST;
        if (reply_ret < 0) {
                if (reply_ret == -LTTNG_ERR_SESSION_NOT_EXIST) {
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_SESSION_DOES_NOT_EXIST;

-               } else if (reply_ret ==
-                               -LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY) {
+               } else if (reply_ret == -LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY) {

                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY;
                } else {
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY;
                } else {
                        status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_ERROR;


@@ -444,9 +412,10 @@ lttng_process_attr_tracker_handle_get_inclusion_set(
                goto end;
        }
 
                goto end;
        }
 

-       inclusion_set_ret = lttng_process_attr_values_create_from_buffer(
-                       tracker->domain, tracker->process_attr,
-                       &inclusion_set_view, &tracker->inclusion_set);
+       inclusion_set_ret = lttng_process_attr_values_create_from_buffer(tracker->domain,
+                                                                        tracker->process_attr,
+                                                                        &inclusion_set_view,
+                                                                        &tracker->inclusion_set);

        if (inclusion_set_ret < 0) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR;
                goto end;
        if (inclusion_set_ret < 0) {
                status = LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_COMMUNICATION_ERROR;
                goto end;


@@ -457,12 +426,11 @@ end:
        return status;
 }
 
        return status;
 }
 

-enum lttng_process_attr_values_status lttng_process_attr_values_get_count(
-               const struct lttng_process_attr_values *values,
-               unsigned int *count)
+enum lttng_process_attr_values_status
+lttng_process_attr_values_get_count(const struct lttng_process_attr_values *values,
+                                   unsigned int *count)

 {
 {

-       enum lttng_process_attr_values_status status =
-                       LTTNG_PROCESS_ATTR_VALUES_STATUS_OK;
+       enum lttng_process_attr_values_status status = LTTNG_PROCESS_ATTR_VALUES_STATUS_OK;

 
        if (!values || !count) {
                status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID;
 
        if (!values || !count) {
                status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID;


@@ -474,9 +442,9 @@ end:
        return status;
 }
 
        return status;
 }
 

-enum lttng_process_attr_value_type lttng_process_attr_values_get_type_at_index(
-               const struct lttng_process_attr_values *values,
-               unsigned int index)
+enum lttng_process_attr_value_type
+lttng_process_attr_values_get_type_at_index(const struct lttng_process_attr_values *values,
+                                           unsigned int index)

 {
        enum lttng_process_attr_value_type type;
        const struct process_attr_value *value;
 {
        enum lttng_process_attr_value_type type;
        const struct process_attr_value *value;


@@ -497,39 +465,35 @@ end:
        return type;
 }
 
        return type;
 }
 

-#define DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(                                       \
-               value_type_name, value_type, expected_value_type)                      \
-       enum lttng_process_attr_values_status                                          \
-                       lttng_process_attr_values_get_##value_type_name##_at_index(    \
-                                       const struct lttng_process_attr_values         \
-                                                       *values,                       \
-                                       unsigned int index,                            \
-                                       value_type *out_value)                         \
-       {                                                                              \
-               enum lttng_process_attr_values_status status =                         \
-                               LTTNG_PROCESS_ATTR_VALUES_STATUS_OK;                   \
-               const struct process_attr_value *value;                                \
-                                                                                       \
-               if (!values) {                                                         \
-                       status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID;             \
-                       goto end;                                                      \
-               }                                                                      \
-                                                                                       \
-               if (_lttng_process_attr_values_get_count(values) <= index) {           \
-                       status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID;             \
-                       goto end;                                                      \
-               }                                                                      \
-                                                                                       \
-               value = lttng_process_attr_tracker_values_get_at_index(                \
-                               values, index);                                        \
-               if (value->type !=                                                     \
-                               LTTNG_PROCESS_ATTR_VALUE_TYPE_##expected_value_type) { \
-                       status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID_TYPE;        \
-                       goto end;                                                      \
-               }                                                                      \
-               *out_value = value->value.value_type_name;                             \
-       end:                                                                           \
-               return status;                                                         \
+#define DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(value_type_name, value_type, expected_value_type) \
+       enum lttng_process_attr_values_status                                                     \
+               lttng_process_attr_values_get_##value_type_name##_at_index(                       \
+                       const struct lttng_process_attr_values *values,                           \
+                       unsigned int index,                                                       \
+                       value_type *out_value)                                                    \
+       {                                                                                         \
+               enum lttng_process_attr_values_status status =                                    \
+                       LTTNG_PROCESS_ATTR_VALUES_STATUS_OK;                                      \
+               const struct process_attr_value *value;                                           \
+                                                                                                  \
+               if (!values) {                                                                    \
+                       status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID;                        \
+                       goto end;                                                                 \
+               }                                                                                 \
+                                                                                                  \
+               if (_lttng_process_attr_values_get_count(values) <= index) {                      \
+                       status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID;                        \
+                       goto end;                                                                 \
+               }                                                                                 \
+                                                                                                  \
+               value = lttng_process_attr_tracker_values_get_at_index(values, index);            \
+               if (value->type != LTTNG_PROCESS_ATTR_VALUE_TYPE_##expected_value_type) {         \
+                       status = LTTNG_PROCESS_ATTR_VALUES_STATUS_INVALID_TYPE;                   \
+                       goto end;                                                                 \
+               }                                                                                 \
+               *out_value = value->value.value_type_name;                                        \
+       end:                                                                                      \
+               return status;                                                                    \

        }
 
 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(pid, pid_t, PID);
        }
 
 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(pid, pid_t, PID);


@@ -538,8 +502,8 @@ DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(gid, gid_t, GID);
 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(user_name, const char *, USER_NAME);
 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(group_name, const char *, GROUP_NAME);
 
 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(user_name, const char *, USER_NAME);
 DEFINE_LTTNG_PROCESS_ATTR_VALUES_GETTER(group_name, const char *, GROUP_NAME);
 

-static enum lttng_error_code handle_status_to_error_code(
-               enum lttng_process_attr_tracker_handle_status handle_status)
+static enum lttng_error_code
+handle_status_to_error_code(enum lttng_process_attr_tracker_handle_status handle_status)

 {
        switch (handle_status) {
        case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY:
 {
        switch (handle_status) {
        case LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY:


@@ -579,26 +543,24 @@ int lttng_track_pid(struct lttng_handle *handle, int pid)
        }
 
        process_attr = handle->domain.type == LTTNG_DOMAIN_KERNEL ?
        }
 
        process_attr = handle->domain.type == LTTNG_DOMAIN_KERNEL ?

-                                      LTTNG_PROCESS_ATTR_PROCESS_ID :
-                                      LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID;
+               LTTNG_PROCESS_ATTR_PROCESS_ID :
+               LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID;

 
 

-       ret_code = lttng_session_get_tracker_handle(handle->session_name,
-                       handle->domain.type,
-                       process_attr, &tracker_handle);
+       ret_code = lttng_session_get_tracker_handle(
+               handle->session_name, handle->domain.type, process_attr, &tracker_handle);

        if (ret_code != LTTNG_OK) {
                goto end;
        }
 
        if (pid == -1) {
                handle_status = lttng_process_attr_tracker_handle_set_tracking_policy(
        if (ret_code != LTTNG_OK) {
                goto end;
        }
 
        if (pid == -1) {
                handle_status = lttng_process_attr_tracker_handle_set_tracking_policy(

-                               tracker_handle,
-                               LTTNG_TRACKING_POLICY_INCLUDE_ALL);
+                       tracker_handle, LTTNG_TRACKING_POLICY_INCLUDE_ALL);

                ret_code = handle_status_to_error_code(handle_status);
                goto end;
        }
 
                ret_code = handle_status_to_error_code(handle_status);
                goto end;
        }
 

-       handle_status = lttng_process_attr_tracker_handle_get_tracking_policy(
-               tracker_handle, &policy);
+       handle_status =
+               lttng_process_attr_tracker_handle_get_tracking_policy(tracker_handle, &policy);

        if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
                ret_code = handle_status_to_error_code(handle_status);
                goto end;
        if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
                ret_code = handle_status_to_error_code(handle_status);
                goto end;


@@ -606,8 +568,7 @@ int lttng_track_pid(struct lttng_handle *handle, int pid)
 
        if (policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
                handle_status = lttng_process_attr_tracker_handle_set_tracking_policy(
 
        if (policy != LTTNG_TRACKING_POLICY_INCLUDE_SET) {
                handle_status = lttng_process_attr_tracker_handle_set_tracking_policy(

-                       tracker_handle,
-                       LTTNG_TRACKING_POLICY_INCLUDE_SET);
+                       tracker_handle, LTTNG_TRACKING_POLICY_INCLUDE_SET);

                if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
                        ret_code = handle_status_to_error_code(handle_status);
                        goto end;
                if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
                        ret_code = handle_status_to_error_code(handle_status);
                        goto end;


@@ -615,12 +576,9 @@ int lttng_track_pid(struct lttng_handle *handle, int pid)
        }
 
        handle_status = process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID ?
        }
 
        handle_status = process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID ?

-                                       lttng_process_attr_process_id_tracker_handle_add_pid(
-                                                       tracker_handle,
-                                                       (pid_t) pid) :
-                                       lttng_process_attr_virtual_process_id_tracker_handle_add_pid(
-                                                       tracker_handle,
-                                                       (pid_t) pid);
+               lttng_process_attr_process_id_tracker_handle_add_pid(tracker_handle, (pid_t) pid) :
+               lttng_process_attr_virtual_process_id_tracker_handle_add_pid(tracker_handle,
+                                                                            (pid_t) pid);

        ret_code = handle_status_to_error_code(handle_status);
 end:
        lttng_process_attr_tracker_handle_destroy(tracker_handle);
        ret_code = handle_status_to_error_code(handle_status);
 end:
        lttng_process_attr_tracker_handle_destroy(tracker_handle);


@@ -645,24 +603,23 @@ int lttng_untrack_pid(struct lttng_handle *handle, int pid)
        }
 
        process_attr = handle->domain.type == LTTNG_DOMAIN_KERNEL ?
        }
 
        process_attr = handle->domain.type == LTTNG_DOMAIN_KERNEL ?

-                                      LTTNG_PROCESS_ATTR_PROCESS_ID :
-                                      LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID;
-       ret_code = lttng_session_get_tracker_handle(handle->session_name,
-                       handle->domain.type, process_attr, &tracker_handle);
+               LTTNG_PROCESS_ATTR_PROCESS_ID :
+               LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID;
+       ret_code = lttng_session_get_tracker_handle(
+               handle->session_name, handle->domain.type, process_attr, &tracker_handle);

        if (ret_code != LTTNG_OK) {
                goto end;
        }
 
        if (pid == -1) {
                handle_status = lttng_process_attr_tracker_handle_set_tracking_policy(
        if (ret_code != LTTNG_OK) {
                goto end;
        }
 
        if (pid == -1) {
                handle_status = lttng_process_attr_tracker_handle_set_tracking_policy(

-                               tracker_handle,
-                               LTTNG_TRACKING_POLICY_EXCLUDE_ALL);
+                       tracker_handle, LTTNG_TRACKING_POLICY_EXCLUDE_ALL);

                ret_code = handle_status_to_error_code(handle_status);
                goto end;
        }
 
                ret_code = handle_status_to_error_code(handle_status);
                goto end;
        }
 

-       handle_status = lttng_process_attr_tracker_handle_get_tracking_policy(
-               tracker_handle, &policy);
+       handle_status =
+               lttng_process_attr_tracker_handle_get_tracking_policy(tracker_handle, &policy);

        if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
                ret_code = handle_status_to_error_code(handle_status);
                goto end;
        if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
                ret_code = handle_status_to_error_code(handle_status);
                goto end;


@@ -677,12 +634,10 @@ int lttng_untrack_pid(struct lttng_handle *handle, int pid)
        }
 
        handle_status = process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID ?
        }
 
        handle_status = process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID ?

-                                       lttng_process_attr_process_id_tracker_handle_remove_pid(
-                                                       tracker_handle,
-                                                       (pid_t) pid) :
-                                       lttng_process_attr_virtual_process_id_tracker_handle_remove_pid(
-                                                       tracker_handle,
-                                                       (pid_t) pid);
+               lttng_process_attr_process_id_tracker_handle_remove_pid(tracker_handle,
+                                                                       (pid_t) pid) :
+               lttng_process_attr_virtual_process_id_tracker_handle_remove_pid(tracker_handle,
+                                                                               (pid_t) pid);

        if (handle_status == LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY) {
                ret_code = LTTNG_ERR_PID_NOT_TRACKED;
        }
        if (handle_status == LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY) {
                ret_code = LTTNG_ERR_PID_NOT_TRACKED;
        }


@@ -702,9 +657,9 @@ end:
  * Returns 0 on success, else a negative LTTng error code.
  */
 int lttng_list_tracker_pids(struct lttng_handle *handle,
  * Returns 0 on success, else a negative LTTng error code.
  */
 int lttng_list_tracker_pids(struct lttng_handle *handle,

-               int *_enabled,
-               int32_t **_pids,
-               size_t *_nr_pids)
+                           int *_enabled,
+                           int32_t **_pids,
+                           size_t *_nr_pids)

 {
        enum lttng_error_code ret_code;
        struct lttng_process_attr_tracker_handle *tracker_handle = NULL;
 {
        enum lttng_error_code ret_code;
        struct lttng_process_attr_tracker_handle *tracker_handle = NULL;


@@ -720,29 +675,28 @@ int lttng_list_tracker_pids(struct lttng_handle *handle,
        }
 
        ret_code = lttng_session_get_tracker_handle(handle->session_name,
        }
 
        ret_code = lttng_session_get_tracker_handle(handle->session_name,

-                       handle->domain.type,
-                       LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID, &tracker_handle);
+                                                   handle->domain.type,
+                                                   LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID,
+                                                   &tracker_handle);

        if (ret_code != LTTNG_OK) {
                goto end;
        }
 
        while (true) {
        if (ret_code != LTTNG_OK) {
                goto end;
        }
 
        while (true) {

-               handle_status = lttng_process_attr_tracker_handle_get_inclusion_set(
-                               tracker_handle, &values);
-               if (handle_status ==
-                               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
+               handle_status = lttng_process_attr_tracker_handle_get_inclusion_set(tracker_handle,
+                                                                                   &values);
+               if (handle_status == LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {

                        policy = LTTNG_TRACKING_POLICY_INCLUDE_SET;
                        break;
                } else if (handle_status !=
                        policy = LTTNG_TRACKING_POLICY_INCLUDE_SET;
                        break;
                } else if (handle_status !=

-                               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY) {
+                          LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_INVALID_TRACKING_POLICY) {

                        ret_code = handle_status_to_error_code(handle_status);
                        goto end;
                }
 
                handle_status = lttng_process_attr_tracker_handle_get_tracking_policy(
                        ret_code = handle_status_to_error_code(handle_status);
                        goto end;
                }
 
                handle_status = lttng_process_attr_tracker_handle_get_tracking_policy(

-                               tracker_handle, &policy);
-               if (handle_status !=
-                               LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {
+                       tracker_handle, &policy);
+               if (handle_status != LTTNG_PROCESS_ATTR_TRACKER_HANDLE_STATUS_OK) {

                        ret_code = handle_status_to_error_code(handle_status);
                        goto end;
                }
                        ret_code = handle_status_to_error_code(handle_status);
                        goto end;
                }


@@ -765,8 +719,7 @@ int lttng_list_tracker_pids(struct lttng_handle *handle,
        case LTTNG_TRACKING_POLICY_INCLUDE_SET:
        {
                const enum lttng_process_attr_values_status values_status =
        case LTTNG_TRACKING_POLICY_INCLUDE_SET:
        {
                const enum lttng_process_attr_values_status values_status =

-                               lttng_process_attr_values_get_count(
-                                               values, &pid_count);
+                       lttng_process_attr_values_get_count(values, &pid_count);

 
                if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) {
                        ret_code = LTTNG_ERR_UNK;
 
                if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) {
                        ret_code = LTTNG_ERR_UNK;


@@ -789,8 +742,7 @@ int lttng_list_tracker_pids(struct lttng_handle *handle,
        for (i = 0; i < pid_count; i++) {
                pid_t pid;
                const enum lttng_process_attr_values_status values_status =
        for (i = 0; i < pid_count; i++) {
                pid_t pid;
                const enum lttng_process_attr_values_status values_status =

-                               lttng_process_attr_values_get_pid_at_index(
-                                               values, i, &pid);
+                       lttng_process_attr_values_get_pid_at_index(values, i, &pid);

 
                if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) {
                        ret_code = LTTNG_ERR_UNK;
 
                if (values_status != LTTNG_PROCESS_ATTR_VALUES_STATUS_OK) {
                        ret_code = LTTNG_ERR_UNK;