X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fkernel-probe.c;h=42f42f641010b185b13fc0622b5a811b04b460de;hb=48a4000561343808724f7cb5fa8c131877489ccd;hp=d2637f933efa18afb243049353cdab4c089908a2;hpb=959e3c66727698e58a8788aceeda5820b3c938ba;p=lttng-tools.git diff --git a/src/common/kernel-probe.c b/src/common/kernel-probe.c index d2637f933..42f42f641 100644 --- a/src/common/kernel-probe.c +++ b/src/common/kernel-probe.c @@ -6,17 +6,17 @@ */ #include "lttng/lttng-error.h" -#include #include -#include -#include -#include #include #include +#include +#include +#include +#include #include #include -#include #include +#include #include #include #include @@ -49,6 +49,16 @@ static unsigned long lttng_kernel_probe_location_symbol_hash( const struct lttng_kernel_probe_location *location); +static +enum lttng_error_code lttng_kernel_probe_location_address_mi_serialize( + const struct lttng_kernel_probe_location *location, + struct mi_writer *writer); + +static +enum lttng_error_code lttng_kernel_probe_location_symbol_mi_serialize( + const struct lttng_kernel_probe_location *location, + struct mi_writer *writer); + enum lttng_kernel_probe_location_type lttng_kernel_probe_location_get_type( const struct lttng_kernel_probe_location *location) { @@ -60,7 +70,7 @@ static void lttng_kernel_probe_location_address_destroy( struct lttng_kernel_probe_location *location) { - assert(location); + LTTNG_ASSERT(location); free(location); } @@ -70,13 +80,13 @@ void lttng_kernel_probe_location_symbol_destroy( { struct lttng_kernel_probe_location_symbol *location_symbol = NULL; - assert(location); + LTTNG_ASSERT(location); location_symbol = container_of(location, struct lttng_kernel_probe_location_symbol, parent); - assert(location_symbol); + LTTNG_ASSERT(location_symbol); free(location_symbol->symbol_name); free(location); @@ -120,6 +130,7 @@ lttng_kernel_probe_location_address_create(uint64_t address) ret->equal = lttng_kernel_probe_location_address_is_equal; ret->serialize = lttng_kernel_probe_location_address_serialize; ret->hash = lttng_kernel_probe_location_address_hash; + ret->mi_serialize = lttng_kernel_probe_location_address_mi_serialize; end: return ret; @@ -157,6 +168,7 @@ lttng_kernel_probe_location_symbol_create(const char *symbol_name, ret->equal = lttng_kernel_probe_location_symbol_is_equal; ret->serialize = lttng_kernel_probe_location_symbol_serialize; ret->hash = lttng_kernel_probe_location_symbol_hash; + ret->mi_serialize = lttng_kernel_probe_location_symbol_mi_serialize; goto end; error: @@ -174,7 +186,7 @@ lttng_kernel_probe_location_address_get_address( LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK; struct lttng_kernel_probe_location_address *address_location; - assert(offset); + LTTNG_ASSERT(offset); if (!location || lttng_kernel_probe_location_get_type(location) != LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS) { @@ -218,7 +230,7 @@ lttng_kernel_probe_location_symbol_get_offset( LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK; struct lttng_kernel_probe_location_symbol *symbol_location; - assert(offset); + LTTNG_ASSERT(offset); if (!location || lttng_kernel_probe_location_get_type(location) != LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET) { @@ -251,7 +263,7 @@ int lttng_kernel_probe_location_symbol_serialize( goto end; } - assert(lttng_kernel_probe_location_get_type(location) == + LTTNG_ASSERT(lttng_kernel_probe_location_get_type(location) == LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET); original_payload_size = payload->buffer.size; @@ -302,8 +314,8 @@ int lttng_kernel_probe_location_address_serialize( struct lttng_kernel_probe_location_address *location_address; struct lttng_kernel_probe_location_address_comm location_address_comm; - assert(location); - assert(lttng_kernel_probe_location_get_type(location) == + LTTNG_ASSERT(location); + LTTNG_ASSERT(lttng_kernel_probe_location_get_type(location) == LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS); original_payload_size = payload->buffer.size; @@ -326,7 +338,6 @@ end: return ret; } -LTTNG_HIDDEN int lttng_kernel_probe_location_serialize( const struct lttng_kernel_probe_location *location, struct lttng_payload *payload) @@ -370,7 +381,7 @@ int lttng_kernel_probe_location_symbol_create_from_payload( ssize_t ret = 0; size_t expected_size; - assert(location); + LTTNG_ASSERT(location); if (view->buffer.size < sizeof(*location_symbol_comm)) { ret = -LTTNG_ERR_INVALID; @@ -417,7 +428,7 @@ ssize_t lttng_kernel_probe_location_address_create_from_payload( ssize_t ret = 0; size_t expected_size; - assert(location); + LTTNG_ASSERT(location); expected_size = sizeof(*location_address_comm); @@ -440,7 +451,6 @@ end: return ret; } -LTTNG_HIDDEN ssize_t lttng_kernel_probe_location_create_from_payload( struct lttng_payload_view *view, struct lttng_kernel_probe_location **location) @@ -453,8 +463,8 @@ ssize_t lttng_kernel_probe_location_create_from_payload( lttng_payload_view_from_view( view, 0, sizeof(*probe_location_comm)); - assert(view); - assert(location); + LTTNG_ASSERT(view); + LTTNG_ASSERT(location); if (!lttng_payload_view_is_valid(&probe_location_comm_view)) { ret = -LTTNG_ERR_INVALID; @@ -570,8 +580,8 @@ bool lttng_kernel_probe_location_symbol_is_equal( b = container_of(_b, struct lttng_kernel_probe_location_symbol, parent); - assert(a->symbol_name); - assert(b->symbol_name); + LTTNG_ASSERT(a->symbol_name); + LTTNG_ASSERT(b->symbol_name); if (strcmp(a->symbol_name, b->symbol_name)) { goto end; } @@ -586,7 +596,6 @@ end: return is_equal; } -LTTNG_HIDDEN bool lttng_kernel_probe_location_is_equal( const struct lttng_kernel_probe_location *a, const struct lttng_kernel_probe_location *b) @@ -621,8 +630,8 @@ lttng_kernel_probe_location_symbol_copy( const char *symbol_name = NULL; uint64_t offset; - assert(location); - assert(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET); + LTTNG_ASSERT(location); + LTTNG_ASSERT(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET); symbol_location = container_of( location, typeof(*symbol_location), parent); @@ -659,8 +668,8 @@ lttng_kernel_probe_location_address_copy( enum lttng_kernel_probe_location_status status; uint64_t address; - assert(location); - assert(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS); + LTTNG_ASSERT(location); + LTTNG_ASSERT(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS); address_location = container_of( location, typeof(*address_location), parent); @@ -683,7 +692,6 @@ end: return new_location; } -LTTNG_HIDDEN struct lttng_kernel_probe_location *lttng_kernel_probe_location_copy( const struct lttng_kernel_probe_location *location) { @@ -718,9 +726,154 @@ err: return new_location; } -LTTNG_HIDDEN unsigned long lttng_kernel_probe_location_hash( const struct lttng_kernel_probe_location *location) { return location->hash(location); } + +static +enum lttng_error_code lttng_kernel_probe_location_address_mi_serialize( + const struct lttng_kernel_probe_location *location, + struct mi_writer *writer) +{ + int ret; + enum lttng_error_code ret_code; + enum lttng_kernel_probe_location_status status; + uint64_t address; + + LTTNG_ASSERT(location); + LTTNG_ASSERT(writer); + LTTNG_ASSERT(location->type == LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS); + + status = lttng_kernel_probe_location_address_get_address( + location, &address); + LTTNG_ASSERT(status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); + + /* Open kernel probe location address element. */ + ret = mi_lttng_writer_open_element( + writer, mi_lttng_element_kernel_probe_location_address); + if (ret) { + goto mi_error; + } + + ret = mi_lttng_writer_write_element_unsigned_int(writer, + mi_lttng_element_kernel_probe_location_address_address, + address); + if (ret) { + goto mi_error; + } + + /* Close kernel probe location address element. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto mi_error; + } + + ret_code = LTTNG_OK; + goto end; + +mi_error: + ret_code = LTTNG_ERR_MI_IO_FAIL; +end: + return ret_code; +} + +static +enum lttng_error_code lttng_kernel_probe_location_symbol_mi_serialize( + const struct lttng_kernel_probe_location *location, + struct mi_writer *writer) +{ + int ret; + enum lttng_error_code ret_code; + enum lttng_kernel_probe_location_status status; + const char *name = NULL; + uint64_t offset; + + LTTNG_ASSERT(location); + LTTNG_ASSERT(writer); + LTTNG_ASSERT(location->type == + LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET); + + name = lttng_kernel_probe_location_symbol_get_name(location); + LTTNG_ASSERT(name); + + status = lttng_kernel_probe_location_symbol_get_offset( + location, &offset); + LTTNG_ASSERT(status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK); + + /* Open kernel probe location symbol offset element. */ + ret = mi_lttng_writer_open_element(writer, + mi_lttng_element_kernel_probe_location_symbol_offset); + if (ret) { + goto mi_error; + } + + /* Name. */ + ret = mi_lttng_writer_write_element_string(writer, + mi_lttng_element_kernel_probe_location_symbol_offset_name, + name); + if (ret) { + goto mi_error; + } + + /* Offset. */ + ret = mi_lttng_writer_write_element_unsigned_int(writer, + mi_lttng_element_kernel_probe_location_symbol_offset_offset, + offset); + if (ret) { + goto mi_error; + } + + /* Close kernel probe location symbol offset element. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto mi_error; + } + + ret_code = LTTNG_OK; + goto end; + +mi_error: + ret_code = LTTNG_ERR_MI_IO_FAIL; +end: + return ret_code; +} + +enum lttng_error_code lttng_kernel_probe_location_mi_serialize( + const struct lttng_kernel_probe_location *location, + struct mi_writer *writer) +{ + int ret; + enum lttng_error_code ret_code; + + LTTNG_ASSERT(location); + LTTNG_ASSERT(writer); + + /* Open kernel probe location element. */ + ret = mi_lttng_writer_open_element( + writer, mi_lttng_element_kernel_probe_location); + if (ret) { + goto mi_error; + } + + /* Serialize the location sub type. */ + ret_code = location->mi_serialize(location, writer); + if (ret_code != LTTNG_OK) { + goto end; + } + + /* Close kernel probe location element. */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + goto mi_error; + } + + ret_code = LTTNG_OK; + goto end; + +mi_error: + ret_code = LTTNG_ERR_MI_IO_FAIL; +end: + return ret_code; +}