Cleanup: namespace 'align' macros

[lttng-tools.git] / src / common / userspace-probe.c

diff --git a/src/common/userspace-probe.c b/src/common/userspace-probe.c
index 67b0ee69820c708e28bbd297674f8c3d055b7539..f5ed86367066b3504dadab91d04810c4d69e441b 100644 (file)
--- a/src/common/userspace-probe.c
+++ b/src/common/userspace-probe.c
@@ -6,8 +6,8 @@
  */
 
 #include "lttng/lttng-error.h"
  */
 
 #include "lttng/lttng-error.h"

-#include <assert.h>

 #include <common/compat/string.h>
 #include <common/compat/string.h>

+#include <common/align.h>

 #include <common/error.h>
 #include <common/hashtable/hashtable.h>
 #include <common/hashtable/utils.h>
 #include <common/error.h>
 #include <common/hashtable/hashtable.h>
 #include <common/hashtable/utils.h>


@@ -115,12 +115,12 @@ void lttng_userspace_probe_location_function_destroy(
 {
        struct lttng_userspace_probe_location_function *location_function = NULL;
 
 {
        struct lttng_userspace_probe_location_function *location_function = NULL;
 

-       assert(location);
+       LTTNG_ASSERT(location);

 
        location_function = container_of(location,
                        struct lttng_userspace_probe_location_function, parent);
 
 
        location_function = container_of(location,
                        struct lttng_userspace_probe_location_function, parent);
 

-       assert(location_function);
+       LTTNG_ASSERT(location_function);

 
        free(location_function->function_name);
        free(location_function->binary_path);
 
        free(location_function->function_name);
        free(location_function->binary_path);


@@ -134,13 +134,13 @@ void lttng_userspace_probe_location_tracepoint_destroy(
 {
        struct lttng_userspace_probe_location_tracepoint *location_tracepoint = NULL;
 
 {
        struct lttng_userspace_probe_location_tracepoint *location_tracepoint = NULL;
 

-       assert(location);
+       LTTNG_ASSERT(location);

 
        location_tracepoint = container_of(location,
                        struct lttng_userspace_probe_location_tracepoint,
                        parent);
 
 
        location_tracepoint = container_of(location,
                        struct lttng_userspace_probe_location_tracepoint,
                        parent);
 

-       assert(location_tracepoint);
+       LTTNG_ASSERT(location_tracepoint);

 
        free(location_tracepoint->probe_name);
        free(location_tracepoint->provider_name);
 
        free(location_tracepoint->probe_name);
        free(location_tracepoint->provider_name);


@@ -253,14 +253,14 @@ static bool lttng_userspace_probe_location_function_is_equal(
                goto end;
        }
 
                goto end;
        }
 

-       assert(a->function_name);
-       assert(b->function_name);
+       LTTNG_ASSERT(a->function_name);
+       LTTNG_ASSERT(b->function_name);

        if (strcmp(a->function_name, b->function_name)) {
                goto end;
        }
 
        if (strcmp(a->function_name, b->function_name)) {
                goto end;
        }
 

-       assert(a->binary_path);
-       assert(b->binary_path);
+       LTTNG_ASSERT(a->binary_path);
+       LTTNG_ASSERT(b->binary_path);

        if (strcmp(a->binary_path, b->binary_path)) {
                goto end;
        }
        if (strcmp(a->binary_path, b->binary_path)) {
                goto end;
        }


@@ -375,20 +375,20 @@ static bool lttng_userspace_probe_location_tracepoint_is_equal(
        b = container_of(_b, struct lttng_userspace_probe_location_tracepoint,
                        parent);
 
        b = container_of(_b, struct lttng_userspace_probe_location_tracepoint,
                        parent);
 

-       assert(a->probe_name);
-       assert(b->probe_name);
+       LTTNG_ASSERT(a->probe_name);
+       LTTNG_ASSERT(b->probe_name);

        if (strcmp(a->probe_name, b->probe_name)) {
                goto end;
        }
 
        if (strcmp(a->probe_name, b->probe_name)) {
                goto end;
        }
 

-       assert(a->provider_name);
-       assert(b->provider_name);
+       LTTNG_ASSERT(a->provider_name);
+       LTTNG_ASSERT(b->provider_name);

        if (strcmp(a->provider_name, b->provider_name)) {
                goto end;
        }
 
        if (strcmp(a->provider_name, b->provider_name)) {
                goto end;
        }
 

-       assert(a->binary_path);
-       assert(b->binary_path);
+       LTTNG_ASSERT(a->binary_path);
+       LTTNG_ASSERT(b->binary_path);

        if (strcmp(a->binary_path, b->binary_path)) {
                goto end;
        }
        if (strcmp(a->binary_path, b->binary_path)) {
                goto end;
        }


@@ -543,8 +543,8 @@ lttng_userspace_probe_location_lookup_method_function_elf_copy(
        struct lttng_userspace_probe_location_lookup_method *parent = NULL;
        struct lttng_userspace_probe_location_lookup_method_elf *elf_method;
 
        struct lttng_userspace_probe_location_lookup_method *parent = NULL;
        struct lttng_userspace_probe_location_lookup_method_elf *elf_method;
 

-       assert(lookup_method);
-       assert(lookup_method->type ==
+       LTTNG_ASSERT(lookup_method);
+       LTTNG_ASSERT(lookup_method->type ==

                        LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
 
        elf_method = zmalloc(sizeof(*elf_method));
                        LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
 
        elf_method = zmalloc(sizeof(*elf_method));


@@ -570,8 +570,8 @@ lttng_userspace_probe_location_lookup_method_tracepoint_sdt_copy(
        struct lttng_userspace_probe_location_lookup_method *parent = NULL;
        struct lttng_userspace_probe_location_lookup_method_sdt *sdt_method;
 
        struct lttng_userspace_probe_location_lookup_method *parent = NULL;
        struct lttng_userspace_probe_location_lookup_method_sdt *sdt_method;
 

-       assert(lookup_method);
-       assert(lookup_method->type ==
+       LTTNG_ASSERT(lookup_method);
+       LTTNG_ASSERT(lookup_method->type ==

                        LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
 
        sdt_method = zmalloc(sizeof(*sdt_method));
                        LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
 
        sdt_method = zmalloc(sizeof(*sdt_method));


@@ -602,8 +602,8 @@ lttng_userspace_probe_location_function_copy(
        const char *function_name = NULL;
        struct lttng_userspace_probe_location_function *function_location;
 
        const char *function_name = NULL;
        struct lttng_userspace_probe_location_function *function_location;
 

-       assert(location);
-       assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);

        function_location = container_of(
                        location, typeof(*function_location), parent);
 
        function_location = container_of(
                        location, typeof(*function_location), parent);
 


@@ -676,8 +676,8 @@ lttng_userspace_probe_location_tracepoint_copy(
        const char *provider_name = NULL;
        struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
 
        const char *provider_name = NULL;
        struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
 

-       assert(location);
-       assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);

        tracepoint_location = container_of(
                        location, typeof(*tracepoint_location), parent);
 
        tracepoint_location = container_of(
                        location, typeof(*tracepoint_location), parent);
 


@@ -967,7 +967,7 @@ lttng_userspace_probe_location_get_lookup_method(
 {
        struct lttng_userspace_probe_location_lookup_method *ret = NULL;
 
 {
        struct lttng_userspace_probe_location_lookup_method *ret = NULL;
 

-       assert(location);
+       LTTNG_ASSERT(location);

        switch (location->type) {
        case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
        ret = lttng_userspace_probe_location_function_get_lookup_method(
        switch (location->type) {
        case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
        ret = lttng_userspace_probe_location_function_get_lookup_method(


@@ -1017,8 +1017,8 @@ int lttng_userspace_probe_location_function_serialize(
        struct lttng_userspace_probe_location_function *location_function;
        struct lttng_userspace_probe_location_function_comm location_function_comm;
 
        struct lttng_userspace_probe_location_function *location_function;
        struct lttng_userspace_probe_location_function_comm location_function_comm;
 

-       assert(location);
-       assert(lttng_userspace_probe_location_get_type(location) ==
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(lttng_userspace_probe_location_get_type(location) ==

                        LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
 
        location_function = container_of(location,
                        LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
 
        location_function = container_of(location,


@@ -1094,8 +1094,8 @@ int lttng_userspace_probe_location_tracepoint_serialize(
        struct lttng_userspace_probe_location_tracepoint *location_tracepoint;
        struct lttng_userspace_probe_location_tracepoint_comm location_tracepoint_comm;
 
        struct lttng_userspace_probe_location_tracepoint *location_tracepoint;
        struct lttng_userspace_probe_location_tracepoint_comm location_tracepoint_comm;
 

-       assert(location);
-       assert(lttng_userspace_probe_location_get_type(location) ==
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(lttng_userspace_probe_location_get_type(location) ==

                        LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
 
        location_tracepoint = container_of(location,
                        LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
 
        location_tracepoint = container_of(location,


@@ -1180,7 +1180,6 @@ end:
        return ret;
 }
 
        return ret;
 }
 

-LTTNG_HIDDEN

 int lttng_userspace_probe_location_serialize(
                const struct lttng_userspace_probe_location *location,
                struct lttng_payload *payload)
 int lttng_userspace_probe_location_serialize(
                const struct lttng_userspace_probe_location *location,
                struct lttng_payload *payload)


@@ -1248,7 +1247,7 @@ int lttng_userspace_probe_location_function_create_from_payload(
        size_t expected_size;
        struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view);
 
        size_t expected_size;
        struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view);
 

-       assert(location);
+       LTTNG_ASSERT(location);

 
        if (view->buffer.size < sizeof(*location_function_comm)) {
                ret = -LTTNG_ERR_INVALID;
 
        if (view->buffer.size < sizeof(*location_function_comm)) {
                ret = -LTTNG_ERR_INVALID;


@@ -1331,7 +1330,7 @@ int lttng_userspace_probe_location_tracepoint_create_from_payload(
        size_t expected_size;
        struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view);
 
        size_t expected_size;
        struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view);
 

-       assert(location);
+       LTTNG_ASSERT(location);

 
        if (!binary_fd_handle) {
                ret = -LTTNG_ERR_INVALID;
 
        if (!binary_fd_handle) {
                ret = -LTTNG_ERR_INVALID;


@@ -1382,18 +1381,21 @@ int lttng_userspace_probe_location_tracepoint_create_from_payload(
 
        probe_name = lttng_strndup(probe_name_src, LTTNG_SYMBOL_NAME_LEN);
        if (!probe_name) {
 
        probe_name = lttng_strndup(probe_name_src, LTTNG_SYMBOL_NAME_LEN);
        if (!probe_name) {

-               PERROR("lttng_strndup");
+               PERROR("Failed to allocate probe name");
+               ret = -LTTNG_ERR_INVALID;

                goto end;
        }
        provider_name = lttng_strndup(provider_name_src, LTTNG_SYMBOL_NAME_LEN);
        if (!provider_name) {
                goto end;
        }
        provider_name = lttng_strndup(provider_name_src, LTTNG_SYMBOL_NAME_LEN);
        if (!provider_name) {

-               PERROR("lttng_strndup");
+               PERROR("Failed to allocate provider name");
+               ret = -LTTNG_ERR_INVALID;

                goto end;
        }
 
                goto end;
        }
 

-       binary_path = lttng_strndup(binary_path_src, LTTNG_SYMBOL_NAME_LEN);
+       binary_path = lttng_strndup(binary_path_src, LTTNG_PATH_MAX);

        if (!binary_path) {
        if (!binary_path) {

-               PERROR("lttng_strndup");
+               PERROR("Failed to allocate binary path");
+               ret = -LTTNG_ERR_INVALID;

                goto end;
        }
 
                goto end;
        }
 


@@ -1429,8 +1431,8 @@ int lttng_userspace_probe_location_lookup_method_create_from_payload(
        struct lttng_userspace_probe_location_lookup_method_comm *lookup_comm;
        enum lttng_userspace_probe_location_lookup_method_type type;
 
        struct lttng_userspace_probe_location_lookup_method_comm *lookup_comm;
        enum lttng_userspace_probe_location_lookup_method_type type;
 

-       assert(view);
-       assert(lookup_method);
+       LTTNG_ASSERT(view);
+       LTTNG_ASSERT(lookup_method);

 
        if (view->buffer.size < sizeof(*lookup_comm)) {
                ret = -LTTNG_ERR_INVALID;
 
        if (view->buffer.size < sizeof(*lookup_comm)) {
                ret = -LTTNG_ERR_INVALID;


@@ -1470,7 +1472,6 @@ end:
        return ret;
 }
 
        return ret;
 }
 

-LTTNG_HIDDEN

 int lttng_userspace_probe_location_create_from_payload(
                struct lttng_payload_view *view,
                struct lttng_userspace_probe_location **location)
 int lttng_userspace_probe_location_create_from_payload(
                struct lttng_payload_view *view,
                struct lttng_userspace_probe_location **location)


@@ -1484,8 +1485,8 @@ int lttng_userspace_probe_location_create_from_payload(
                        lttng_payload_view_from_view(
                                        view, 0, sizeof(*probe_location_comm));
 
                        lttng_payload_view_from_view(
                                        view, 0, sizeof(*probe_location_comm));
 

-       assert(view);
-       assert(location);
+       LTTNG_ASSERT(view);
+       LTTNG_ASSERT(location);

 
        lookup_method = NULL;
 
 
        lookup_method = NULL;
 


@@ -1548,7 +1549,7 @@ int lttng_userspace_probe_location_create_from_payload(
                goto end;
        }
 
                goto end;
        }
 

-       assert(lookup_method);
+       LTTNG_ASSERT(lookup_method);

        (*location)->lookup_method = lookup_method;
        lookup_method = NULL;
        ret += consumed;
        (*location)->lookup_method = lookup_method;
        lookup_method = NULL;
        ret += consumed;


@@ -1564,8 +1565,8 @@ int lttng_userspace_probe_location_function_set_binary_fd_handle(
        int ret = 0;
        struct lttng_userspace_probe_location_function *function_location;
 
        int ret = 0;
        struct lttng_userspace_probe_location_function *function_location;
 

-       assert(location);
-       assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);

 
        function_location = container_of(location,
                        struct lttng_userspace_probe_location_function, parent);
 
        function_location = container_of(location,
                        struct lttng_userspace_probe_location_function, parent);


@@ -1583,8 +1584,8 @@ int lttng_userspace_probe_location_tracepoint_set_binary_fd_handle(
        int ret = 0;
        struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
 
        int ret = 0;
        struct lttng_userspace_probe_location_tracepoint *tracepoint_location;
 

-       assert(location);
-       assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);

 
        tracepoint_location = container_of(location,
                        struct lttng_userspace_probe_location_tracepoint, parent);
 
        tracepoint_location = container_of(location,
                        struct lttng_userspace_probe_location_tracepoint, parent);


@@ -1608,7 +1609,7 @@ int lttng_userspace_probe_location_function_flatten(
        int storage_needed = 0;
        int ret;
 
        int storage_needed = 0;
        int ret;
 

-       assert(location);
+       LTTNG_ASSERT(location);

 
        if (location->lookup_method && location->lookup_method->type !=
                        LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF) {
 
        if (location->lookup_method && location->lookup_method->type !=
                        LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF) {


@@ -1619,8 +1620,8 @@ int lttng_userspace_probe_location_function_flatten(
        probe_function = container_of(location,
                        struct lttng_userspace_probe_location_function,
                        parent);
        probe_function = container_of(location,
                        struct lttng_userspace_probe_location_function,
                        parent);

-       assert(probe_function->function_name);
-       assert(probe_function->binary_path);
+       LTTNG_ASSERT(probe_function->function_name);
+       LTTNG_ASSERT(probe_function->binary_path);

 
        storage_needed +=
                        sizeof(struct lttng_userspace_probe_location_function);
 
        storage_needed +=
                        sizeof(struct lttng_userspace_probe_location_function);


@@ -1634,7 +1635,7 @@ int lttng_userspace_probe_location_function_flatten(
         * the next structure in the buffer probably needs to be
         * aligned too (depending on the arch).
         */
         * the next structure in the buffer probably needs to be
         * aligned too (depending on the arch).
         */

-       padding_needed = ALIGN_TO(storage_needed, sizeof(uint64_t)) - storage_needed;
+       padding_needed = lttng_align_ceil(storage_needed, sizeof(uint64_t)) - storage_needed;

        storage_needed += padding_needed;
 
        if (location->lookup_method) {
        storage_needed += padding_needed;
 
        if (location->lookup_method) {


@@ -1732,7 +1733,7 @@ int lttng_userspace_probe_location_tracepoint_flatten(
        char *flat_probe_start;
        int ret = 0;
 
        char *flat_probe_start;
        int ret = 0;
 

-       assert(location);
+       LTTNG_ASSERT(location);

 
        /* Only SDT tracepoints are supported at the moment */
        if (location->lookup_method && location->lookup_method->type !=
 
        /* Only SDT tracepoints are supported at the moment */
        if (location->lookup_method && location->lookup_method->type !=


@@ -1743,9 +1744,9 @@ int lttng_userspace_probe_location_tracepoint_flatten(
        probe_tracepoint = container_of(location,
                        struct lttng_userspace_probe_location_tracepoint,
                        parent);
        probe_tracepoint = container_of(location,
                        struct lttng_userspace_probe_location_tracepoint,
                        parent);

-       assert(probe_tracepoint->probe_name);
-       assert(probe_tracepoint->provider_name);
-       assert(probe_tracepoint->binary_path);
+       LTTNG_ASSERT(probe_tracepoint->probe_name);
+       LTTNG_ASSERT(probe_tracepoint->provider_name);
+       LTTNG_ASSERT(probe_tracepoint->binary_path);

 
        /* Compute the storage space needed to flatten the probe location */
        storage_needed += sizeof(struct lttng_userspace_probe_location_tracepoint);
 
        /* Compute the storage space needed to flatten the probe location */
        storage_needed += sizeof(struct lttng_userspace_probe_location_tracepoint);


@@ -1762,7 +1763,7 @@ int lttng_userspace_probe_location_tracepoint_flatten(
         * the next structure in the buffer probably needs to be
         * aligned too (depending on the arch).
         */
         * the next structure in the buffer probably needs to be
         * aligned too (depending on the arch).
         */

-       padding_needed = ALIGN_TO(storage_needed, sizeof(uint64_t)) - storage_needed;
+       padding_needed = lttng_align_ceil(storage_needed, sizeof(uint64_t)) - storage_needed;

        storage_needed += padding_needed;
 
        if (location->lookup_method) {
        storage_needed += padding_needed;
 
        if (location->lookup_method) {


@@ -1858,7 +1859,6 @@ end:
        return ret;
 }
 
        return ret;
 }
 

-LTTNG_HIDDEN

 int lttng_userspace_probe_location_flatten(
                const struct lttng_userspace_probe_location *location,
                struct lttng_dynamic_buffer *buffer)
 int lttng_userspace_probe_location_flatten(
                const struct lttng_userspace_probe_location *location,
                struct lttng_dynamic_buffer *buffer)


@@ -1886,7 +1886,6 @@ end:
        return ret;
 }
 
        return ret;
 }
 

-LTTNG_HIDDEN

 struct lttng_userspace_probe_location *lttng_userspace_probe_location_copy(
                const struct lttng_userspace_probe_location *location)
 {
 struct lttng_userspace_probe_location *lttng_userspace_probe_location_copy(
                const struct lttng_userspace_probe_location *location)
 {


@@ -1921,7 +1920,6 @@ err:
        return new_location;
 }
 
        return new_location;
 }
 

-LTTNG_HIDDEN

 bool lttng_userspace_probe_location_lookup_method_is_equal(
                const struct lttng_userspace_probe_location_lookup_method *a,
                const struct lttng_userspace_probe_location_lookup_method *b)
 bool lttng_userspace_probe_location_lookup_method_is_equal(
                const struct lttng_userspace_probe_location_lookup_method *a,
                const struct lttng_userspace_probe_location_lookup_method *b)


@@ -1946,7 +1944,6 @@ end:
        return is_equal;
 }
 
        return is_equal;
 }
 

-LTTNG_HIDDEN

 bool lttng_userspace_probe_location_is_equal(
                const struct lttng_userspace_probe_location *a,
                const struct lttng_userspace_probe_location *b)
 bool lttng_userspace_probe_location_is_equal(
                const struct lttng_userspace_probe_location *a,
                const struct lttng_userspace_probe_location *b)


@@ -1976,14 +1973,12 @@ end:
        return is_equal;
 }
 
        return is_equal;
 }
 

-LTTNG_HIDDEN

 unsigned long lttng_userspace_probe_location_hash(
                const struct lttng_userspace_probe_location *location)
 {
        return location->hash(location);
 }
 
 unsigned long lttng_userspace_probe_location_hash(
                const struct lttng_userspace_probe_location *location)
 {
        return location->hash(location);
 }
 

-LTTNG_HIDDEN

 enum lttng_error_code lttng_userspace_probe_location_mi_serialize(
                const struct lttng_userspace_probe_location *location,
                struct mi_writer *writer)
 enum lttng_error_code lttng_userspace_probe_location_mi_serialize(
                const struct lttng_userspace_probe_location *location,
                struct mi_writer *writer)


@@ -1996,8 +1991,8 @@ enum lttng_error_code lttng_userspace_probe_location_mi_serialize(
        enum lttng_error_code ret_code;
        mi_fp mi_function = NULL;
 
        enum lttng_error_code ret_code;
        mi_fp mi_function = NULL;
 

-       assert(location);
-       assert(writer);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(writer);

 
        switch (lttng_userspace_probe_location_get_type(location)) {
        case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:
 
        switch (lttng_userspace_probe_location_get_type(location)) {
        case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION:


@@ -2048,8 +2043,8 @@ enum lttng_error_code lttng_userspace_probe_location_lookup_method_mi_serialize(
        enum lttng_error_code ret_code;
        const char *type_element_str;
 
        enum lttng_error_code ret_code;
        const char *type_element_str;
 

-       assert(method);
-       assert(writer);
+       LTTNG_ASSERT(method);
+       LTTNG_ASSERT(writer);

 
        switch (lttng_userspace_probe_location_lookup_method_get_type(method)) {
        case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:
 
        switch (lttng_userspace_probe_location_lookup_method_get_type(method)) {
        case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT:


@@ -2109,8 +2104,8 @@ static enum lttng_error_code lttng_userspace_probe_location_tracepoint_mi_serial
        const struct lttng_userspace_probe_location_lookup_method
                        *lookup_method = NULL;
 
        const struct lttng_userspace_probe_location_lookup_method
                        *lookup_method = NULL;
 

-       assert(location);
-       assert(writer);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(writer);

 
        probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
                        location);
 
        probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
                        location);


@@ -2188,8 +2183,8 @@ static enum lttng_error_code lttng_userspace_probe_location_function_mi_serializ
        const struct lttng_userspace_probe_location_lookup_method
                        *lookup_method = NULL;
 
        const struct lttng_userspace_probe_location_lookup_method
                        *lookup_method = NULL;
 

-       assert(location);
-       assert(writer);
+       LTTNG_ASSERT(location);
+       LTTNG_ASSERT(writer);

 
        function_name = lttng_userspace_probe_location_function_get_function_name(
                        location);
 
        function_name = lttng_userspace_probe_location_function_get_function_name(
                        location);