X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fuserspace-probe.c;h=609ffc1ac22874cb5d944a2ced6adcc0cf07e2b2;hp=7f038f5b53ec8a0e76d77df6c121542dbb3129f9;hb=3e6e0df2f8f9f23d252c2508b6d741916dfcc4b3;hpb=9d3981b5c746b87954c46218b2c7c6e76ae7ed46 diff --git a/src/common/userspace-probe.c b/src/common/userspace-probe.c index 7f038f5b5..609ffc1ac 100644 --- a/src/common/userspace-probe.c +++ b/src/common/userspace-probe.c @@ -1,27 +1,33 @@ /* - * Copyright (C) 2017 - Jérémie Galarneau + * Copyright (C) 2017 Jérémie Galarneau * - * This library is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License, version 2.1 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: LGPL-2.1-only * - * This library is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License - * for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this library; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "lttng/lttng-error.h" #include +#include #include #include -#include +#include +#include #include #include #include +#include +#include +#include + +static +int lttng_userspace_probe_location_function_set_binary_fd_handle( + struct lttng_userspace_probe_location *location, + struct fd_handle *binary_fd_handle); + +static +int lttng_userspace_probe_location_tracepoint_set_binary_fd_handle( + struct lttng_userspace_probe_location *location, + struct fd_handle *binary_fd_handle); enum lttng_userspace_probe_location_lookup_method_type lttng_userspace_probe_location_lookup_method_get_type( @@ -99,11 +105,7 @@ void lttng_userspace_probe_location_function_destroy( free(location_function->function_name); free(location_function->binary_path); - if (location_function->binary_fd >= 0) { - if (close(location_function->binary_fd)) { - PERROR("close"); - } - } + fd_handle_put(location_function->binary_fd_handle); free(location); } @@ -124,11 +126,7 @@ void lttng_userspace_probe_location_tracepoint_destroy( free(location_tracepoint->probe_name); free(location_tracepoint->provider_name); free(location_tracepoint->binary_path); - if (location_tracepoint->binary_fd >= 0) { - if (close(location_tracepoint->binary_fd)) { - PERROR("close"); - } - } + fd_handle_put(location_tracepoint->binary_fd_handle); free(location); } @@ -154,6 +152,87 @@ void lttng_userspace_probe_location_destroy( } } +/* Compare two file descriptors based on their inode and device numbers. */ +static bool fd_is_equal(int a, int b) +{ + int ret; + bool is_equal = false; + struct stat a_stat, b_stat; + + if (a < 0 && b >= 0) { + goto end; + } + + if (b < 0 && a >= 0) { + goto end; + } + + if (a < 0 && b < 0) { + if (a == -1 && b == -1) { + is_equal = true; + goto end; + } + + /* Invalid state, abort. */ + abort(); + } + + /* Both are valid file descriptors. */ + ret = fstat(a, &a_stat); + if (ret) { + PERROR("Failed to fstat userspace probe location binary fd %d", + a); + goto end; + } + + ret = fstat(b, &b_stat); + if (ret) { + PERROR("Failed to fstat userspace probe location binary fd %d", + b); + goto end; + } + + is_equal = (a_stat.st_ino == b_stat.st_ino) && + (a_stat.st_dev == b_stat.st_dev); + +end: + return is_equal; +} + +static bool lttng_userspace_probe_location_function_is_equal( + const struct lttng_userspace_probe_location *_a, + const struct lttng_userspace_probe_location *_b) +{ + bool is_equal = false; + struct lttng_userspace_probe_location_function *a, *b; + + a = container_of(_a, struct lttng_userspace_probe_location_function, + parent); + b = container_of(_b, struct lttng_userspace_probe_location_function, + parent); + + if (a->instrumentation_type != b->instrumentation_type) { + goto end; + } + + assert(a->function_name); + assert(b->function_name); + if (strcmp(a->function_name, b->function_name)) { + goto end; + } + + assert(a->binary_path); + assert(b->binary_path); + if (strcmp(a->binary_path, b->binary_path)) { + goto end; + } + + is_equal = fd_is_equal(a->binary_fd_handle ? fd_handle_get_fd(a->binary_fd_handle) : -1, + b->binary_fd_handle ? fd_handle_get_fd(b->binary_fd_handle) : -1); +end: + return is_equal; +} + static struct lttng_userspace_probe_location * lttng_userspace_probe_location_function_create_no_check(const char *binary_path, const char *function_name, @@ -161,6 +240,7 @@ lttng_userspace_probe_location_function_create_no_check(const char *binary_path, bool open_binary) { int binary_fd = -1; + struct fd_handle *binary_fd_handle = NULL; char *function_name_copy = NULL, *binary_path_copy = NULL; struct lttng_userspace_probe_location *ret = NULL; struct lttng_userspace_probe_location_function *location; @@ -171,7 +251,13 @@ lttng_userspace_probe_location_function_create_no_check(const char *binary_path, PERROR("Error opening the binary"); goto error; } - } else { + + binary_fd_handle = fd_handle_create(binary_fd); + if (!binary_fd) { + goto error; + } + + /* Ownership transferred to fd_handle. */ binary_fd = -1; } @@ -195,13 +281,15 @@ lttng_userspace_probe_location_function_create_no_check(const char *binary_path, location->function_name = function_name_copy; location->binary_path = binary_path_copy; - location->binary_fd = binary_fd; + location->binary_fd_handle = binary_fd_handle; + binary_fd_handle = NULL; location->instrumentation_type = LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_ENTRY; ret = &location->parent; ret->lookup_method = lookup_method; ret->type = LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION; + ret->equal = lttng_userspace_probe_location_function_is_equal; goto end; error: @@ -212,10 +300,48 @@ error: PERROR("Error closing binary fd in error path"); } } + fd_handle_put(binary_fd_handle); end: return ret; } +static bool lttng_userspace_probe_location_tracepoint_is_equal( + const struct lttng_userspace_probe_location *_a, + const struct lttng_userspace_probe_location *_b) +{ + bool is_equal = false; + struct lttng_userspace_probe_location_tracepoint *a, *b; + + a = container_of(_a, 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); + if (strcmp(a->probe_name, b->probe_name)) { + goto end; + } + + assert(a->provider_name); + assert(b->provider_name); + if (strcmp(a->provider_name, b->provider_name)) { + goto end; + } + + assert(a->binary_path); + assert(b->binary_path); + if (strcmp(a->binary_path, b->binary_path)) { + goto end; + } + + is_equal = fd_is_equal(a->binary_fd_handle ? fd_handle_get_fd(a->binary_fd_handle) : -1, + b->binary_fd_handle ? fd_handle_get_fd(b->binary_fd_handle) : -1); + +end: + return is_equal; +} + static struct lttng_userspace_probe_location * lttng_userspace_probe_location_tracepoint_create_no_check(const char *binary_path, const char *provider_name, const char *probe_name, @@ -223,6 +349,7 @@ lttng_userspace_probe_location_tracepoint_create_no_check(const char *binary_pat bool open_binary) { int binary_fd = -1; + struct fd_handle *binary_fd_handle = NULL; char *probe_name_copy = NULL; char *provider_name_copy = NULL; char *binary_path_copy = NULL; @@ -235,7 +362,13 @@ lttng_userspace_probe_location_tracepoint_create_no_check(const char *binary_pat PERROR("open"); goto error; } - } else { + + binary_fd_handle = fd_handle_create(binary_fd); + if (!binary_fd) { + goto error; + } + + /* Ownership transferred to fd_handle. */ binary_fd = -1; } @@ -266,21 +399,25 @@ lttng_userspace_probe_location_tracepoint_create_no_check(const char *binary_pat location->probe_name = probe_name_copy; location->provider_name = provider_name_copy; location->binary_path = binary_path_copy; - location->binary_fd = binary_fd; + location->binary_fd_handle = binary_fd_handle; + binary_fd_handle = NULL; ret = &location->parent; ret->lookup_method = lookup_method; ret->type = LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT; + ret->equal = lttng_userspace_probe_location_tracepoint_is_equal; goto end; error: free(probe_name_copy); free(provider_name_copy); + free(binary_path_copy); if (binary_fd >= 0) { if (close(binary_fd)) { PERROR("Error closing binary fd in error path"); } } + fd_handle_put(binary_fd_handle); end: return ret; } @@ -293,7 +430,7 @@ lttng_userspace_probe_location_function_create(const char *binary_path, struct lttng_userspace_probe_location *ret = NULL; if (!binary_path || !function_name) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -321,7 +458,7 @@ lttng_userspace_probe_location_tracepoint_create(const char *binary_path, struct lttng_userspace_probe_location *ret = NULL; if (!binary_path || !probe_name || !provider_name) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -402,33 +539,25 @@ lttng_userspace_probe_location_function_copy( enum lttng_userspace_probe_location_lookup_method_type lookup_type; struct lttng_userspace_probe_location *new_location = NULL; struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL; - char *binary_path = NULL; - char *function_name = NULL; - int fd; + const char *binary_path = NULL; + const char *function_name = NULL; + struct lttng_userspace_probe_location_function *function_location; assert(location); assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION); + function_location = container_of( + location, typeof(*function_location), parent); - /* Duplicate probe location fields */ - binary_path = - lttng_strndup(lttng_userspace_probe_location_function_get_binary_path(location), - LTTNG_PATH_MAX); + /* Get probe location fields */ + binary_path = lttng_userspace_probe_location_function_get_binary_path(location); if (!binary_path) { + ERR("Userspace probe binary path is NULL"); goto error; } - function_name = - lttng_strndup(lttng_userspace_probe_location_function_get_function_name(location), - LTTNG_SYMBOL_NAME_LEN); + function_name = lttng_userspace_probe_location_function_get_function_name(location); if (!function_name) { - PERROR("Error duplicating function name string"); - goto error; - } - - /* Duplicate the binary fd */ - fd = dup(lttng_userspace_probe_location_function_get_binary_fd(location)); - if (fd == -1) { - PERROR("Error duplicating file descriptor to binary"); + ERR("Userspace probe function name is NULL"); goto error; } @@ -443,23 +572,24 @@ lttng_userspace_probe_location_function_copy( lttng_userspace_probe_location_lookup_method_function_elf_copy( location->lookup_method); if (!lookup_method) { - goto close_fd; + goto error; } break; default: /* Invalid probe location lookup method. */ - goto close_fd; + goto error; } /* Create the probe_location */ new_location = lttng_userspace_probe_location_function_create_no_check( - binary_path, function_name, lookup_method, true); + binary_path, function_name, lookup_method, false); if (!new_location) { goto destroy_lookup_method; } /* Set the duplicated fd to the new probe_location */ - if (lttng_userspace_probe_location_function_set_binary_fd(new_location, fd) < 0) { + if (lttng_userspace_probe_location_function_set_binary_fd_handle(new_location, + function_location->binary_fd_handle) < 0) { goto destroy_probe_location; } @@ -469,13 +599,7 @@ destroy_probe_location: lttng_userspace_probe_location_destroy(new_location); destroy_lookup_method: lttng_userspace_probe_location_lookup_method_destroy(lookup_method); -close_fd: - if (close(fd) < 0) { - PERROR("Error closing duplicated file descriptor in error path"); - } error: - free(function_name); - free(binary_path); new_location = NULL; end: return new_location; @@ -488,43 +612,32 @@ lttng_userspace_probe_location_tracepoint_copy( enum lttng_userspace_probe_location_lookup_method_type lookup_type; struct lttng_userspace_probe_location *new_location = NULL; struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL; - char *binary_path = NULL; - char *probe_name = NULL; - char *provider_name = NULL; - int fd; + const char *binary_path = NULL; + const char *probe_name = NULL; + const char *provider_name = NULL; + struct lttng_userspace_probe_location_tracepoint *tracepoint_location; assert(location); assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT); + tracepoint_location = container_of( + location, typeof(*tracepoint_location), parent); - /* Duplicate probe location fields */ - binary_path = - lttng_strndup(lttng_userspace_probe_location_tracepoint_get_binary_path(location), - LTTNG_PATH_MAX); + /* Get probe location fields */ + binary_path = lttng_userspace_probe_location_tracepoint_get_binary_path(location); if (!binary_path) { - PERROR("lttng_strndup"); + ERR("Userspace probe binary path is NULL"); goto error; } - probe_name = - lttng_strndup(lttng_userspace_probe_location_tracepoint_get_probe_name(location), - LTTNG_SYMBOL_NAME_LEN); + probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(location); if (!probe_name) { - PERROR("lttng_strndup"); + ERR("Userspace probe probe name is NULL"); goto error; } - provider_name = - lttng_strndup(lttng_userspace_probe_location_tracepoint_get_provider_name(location), - LTTNG_SYMBOL_NAME_LEN); + provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(location); if (!provider_name) { - PERROR("lttng_strndup"); - goto error; - } - - /* Duplicate the binary fd */ - fd = dup(lttng_userspace_probe_location_tracepoint_get_binary_fd(location)); - if (fd == -1) { - PERROR("dup"); + ERR("Userspace probe provider name is NULL"); goto error; } @@ -539,23 +652,24 @@ lttng_userspace_probe_location_tracepoint_copy( lttng_userspace_probe_location_lookup_method_tracepoint_sdt_copy( location->lookup_method); if (!lookup_method) { - goto close_fd; + goto error; } break; default: /* Invalid probe location lookup method. */ - goto close_fd; + goto error; } /* Create the probe_location */ new_location = lttng_userspace_probe_location_tracepoint_create_no_check( - binary_path, provider_name, probe_name, lookup_method, true); + binary_path, provider_name, probe_name, lookup_method, false); if (!new_location) { goto destroy_lookup_method; } /* Set the duplicated fd to the new probe_location */ - if (lttng_userspace_probe_location_tracepoint_set_binary_fd(new_location, fd) < 0) { + if (lttng_userspace_probe_location_tracepoint_set_binary_fd_handle(new_location, + tracepoint_location->binary_fd_handle) < 0) { goto destroy_probe_location; } @@ -565,14 +679,7 @@ destroy_probe_location: lttng_userspace_probe_location_destroy(new_location); destroy_lookup_method: lttng_userspace_probe_location_lookup_method_destroy(lookup_method); -close_fd: - if (close(fd) < 0) { - PERROR("close"); - } error: - free(provider_name); - free(probe_name); - free(binary_path); new_location = NULL; end: return new_location; @@ -586,7 +693,7 @@ const char *lttng_userspace_probe_location_function_get_binary_path( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -606,7 +713,7 @@ const char *lttng_userspace_probe_location_tracepoint_get_binary_path( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -626,7 +733,7 @@ const char *lttng_userspace_probe_location_function_get_function_name( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -645,7 +752,7 @@ const char *lttng_userspace_probe_location_tracepoint_get_probe_name( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -664,7 +771,7 @@ const char *lttng_userspace_probe_location_tracepoint_get_provider_name( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -683,13 +790,14 @@ int lttng_userspace_probe_location_function_get_binary_fd( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } function_location = container_of(location, struct lttng_userspace_probe_location_function, parent); - ret = function_location->binary_fd; + ret = function_location->binary_fd_handle ? + fd_handle_get_fd(function_location->binary_fd_handle) : -1; end: return ret; } @@ -703,7 +811,7 @@ lttng_userspace_probe_location_function_get_instrumentation_type( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); type = LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_UNKNOWN; goto end; } @@ -728,7 +836,7 @@ lttng_userspace_probe_location_function_set_instrumentation_type( LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION || instrumentation_type != LTTNG_USERSPACE_PROBE_LOCATION_FUNCTION_INSTRUMENTATION_TYPE_ENTRY) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); status = LTTNG_USERSPACE_PROBE_LOCATION_STATUS_INVALID; goto end; } @@ -748,13 +856,14 @@ int lttng_userspace_probe_location_tracepoint_get_binary_fd( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } tracepoint_location = container_of(location, struct lttng_userspace_probe_location_tracepoint, parent); - ret = tracepoint_location->binary_fd; + ret = tracepoint_location->binary_fd_handle ? + fd_handle_get_fd(tracepoint_location->binary_fd_handle) : -1; end: return ret; } @@ -767,7 +876,7 @@ lttng_userspace_probe_location_function_get_lookup_method( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -784,7 +893,7 @@ lttng_userspace_probe_location_tracepoint_get_lookup_method( if (!location || lttng_userspace_probe_location_get_type(location) != LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); goto end; } @@ -819,7 +928,7 @@ lttng_userspace_probe_location_get_lookup_method( static int lttng_userspace_probe_location_lookup_method_serialize( struct lttng_userspace_probe_location_lookup_method *method, - struct lttng_dynamic_buffer *buffer) + struct lttng_payload *payload) { int ret; struct lttng_userspace_probe_location_lookup_method_comm @@ -827,8 +936,8 @@ int lttng_userspace_probe_location_lookup_method_serialize( lookup_method_comm.type = (int8_t) (method ? method->type : LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_DEFAULT); - if (buffer) { - ret = lttng_dynamic_buffer_append(buffer, &lookup_method_comm, + if (payload) { + ret = lttng_dynamic_buffer_append(&payload->buffer, &lookup_method_comm, sizeof(lookup_method_comm)); if (ret) { goto end; @@ -842,8 +951,7 @@ end: static int lttng_userspace_probe_location_function_serialize( const struct lttng_userspace_probe_location *location, - struct lttng_dynamic_buffer *buffer, - int *binary_fd) + struct lttng_payload *payload) { int ret; size_t function_name_len, binary_path_len; @@ -862,15 +970,11 @@ int lttng_userspace_probe_location_function_serialize( goto end; } - if (binary_fd && location_function->binary_fd < 0) { + if (payload && !location_function->binary_fd_handle) { ret = -LTTNG_ERR_INVALID; goto end; } - if (binary_fd) { - *binary_fd = location_function->binary_fd; - } - function_name_len = strlen(location_function->function_name); if (function_name_len == 0) { ret = -LTTNG_ERR_INVALID; @@ -885,28 +989,34 @@ int lttng_userspace_probe_location_function_serialize( location_function_comm.function_name_len = function_name_len + 1; location_function_comm.binary_path_len = binary_path_len + 1; - if (buffer) { - ret = lttng_dynamic_buffer_append(buffer, + if (payload) { + ret = lttng_dynamic_buffer_append(&payload->buffer, &location_function_comm, sizeof(location_function_comm)); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } - ret = lttng_dynamic_buffer_append(buffer, + ret = lttng_dynamic_buffer_append(&payload->buffer, location_function->function_name, location_function_comm.function_name_len); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } - ret = lttng_dynamic_buffer_append(buffer, + ret = lttng_dynamic_buffer_append(&payload->buffer, location_function->binary_path, location_function_comm.binary_path_len); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } + ret = lttng_payload_push_fd_handle( + payload, location_function->binary_fd_handle); + if (ret) { + ret = -LTTNG_ERR_INVALID; + goto end; + } } ret = sizeof(location_function_comm) + location_function_comm.function_name_len + @@ -918,8 +1028,7 @@ end: static int lttng_userspace_probe_location_tracepoint_serialize( const struct lttng_userspace_probe_location *location, - struct lttng_dynamic_buffer *buffer, - int *binary_fd) + struct lttng_payload *payload) { int ret; size_t probe_name_len, provider_name_len, binary_path_len; @@ -940,15 +1049,11 @@ int lttng_userspace_probe_location_tracepoint_serialize( goto end; } - if (binary_fd && location_tracepoint->binary_fd < 0) { + if (payload && !location_tracepoint->binary_fd_handle) { ret = -LTTNG_ERR_INVALID; goto end; } - if (binary_fd) { - *binary_fd = location_tracepoint->binary_fd; - } - probe_name_len = strlen(location_tracepoint->probe_name); if (probe_name_len == 0) { ret = -LTTNG_ERR_INVALID; @@ -971,36 +1076,43 @@ int lttng_userspace_probe_location_tracepoint_serialize( location_tracepoint_comm.provider_name_len = provider_name_len + 1; location_tracepoint_comm.binary_path_len = binary_path_len + 1; - if (buffer) { - ret = lttng_dynamic_buffer_append(buffer, + if (payload) { + ret = lttng_dynamic_buffer_append(&payload->buffer, &location_tracepoint_comm, sizeof(location_tracepoint_comm)); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } - ret = lttng_dynamic_buffer_append(buffer, + ret = lttng_dynamic_buffer_append(&payload->buffer, location_tracepoint->probe_name, location_tracepoint_comm.probe_name_len); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } - ret = lttng_dynamic_buffer_append(buffer, + ret = lttng_dynamic_buffer_append(&payload->buffer, location_tracepoint->provider_name, location_tracepoint_comm.provider_name_len); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } - ret = lttng_dynamic_buffer_append(buffer, + ret = lttng_dynamic_buffer_append(&payload->buffer, location_tracepoint->binary_path, location_tracepoint_comm.binary_path_len); if (ret) { ret = -LTTNG_ERR_INVALID; goto end; } + ret = lttng_payload_push_fd_handle( + payload, location_tracepoint->binary_fd_handle); + if (ret) { + ret = -LTTNG_ERR_INVALID; + goto end; + } } + ret = sizeof(location_tracepoint_comm) + location_tracepoint_comm.probe_name_len + location_tracepoint_comm.provider_name_len + @@ -1012,14 +1124,13 @@ end: LTTNG_HIDDEN int lttng_userspace_probe_location_serialize( const struct lttng_userspace_probe_location *location, - struct lttng_dynamic_buffer *buffer, - int *binary_fd) + struct lttng_payload *payload) { int ret, buffer_use = 0; struct lttng_userspace_probe_location_comm location_generic_comm; if (!location) { - ERR("Invalid argument(s)"); + ERR("Invalid argument(s) passed to '%s'", __FUNCTION__); ret = -LTTNG_ERR_INVALID; goto end; } @@ -1027,8 +1138,9 @@ int lttng_userspace_probe_location_serialize( memset(&location_generic_comm, 0, sizeof(location_generic_comm)); location_generic_comm.type = (int8_t) location->type; - if (buffer) { - ret = lttng_dynamic_buffer_append(buffer, &location_generic_comm, + if (payload) { + ret = lttng_dynamic_buffer_append(&payload->buffer, + &location_generic_comm, sizeof(location_generic_comm)); if (ret) { goto end; @@ -1039,11 +1151,11 @@ int lttng_userspace_probe_location_serialize( switch (lttng_userspace_probe_location_get_type(location)) { case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION: ret = lttng_userspace_probe_location_function_serialize( - location, buffer, binary_fd); + location, payload); break; case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT: ret = lttng_userspace_probe_location_tracepoint_serialize( - location, buffer, binary_fd); + location, payload); break; default: ERR("Unsupported probe location type"); @@ -1056,7 +1168,7 @@ int lttng_userspace_probe_location_serialize( buffer_use += ret; ret = lttng_userspace_probe_location_lookup_method_serialize( - location->lookup_method, buffer); + location->lookup_method, payload); if (ret < 0) { goto end; } @@ -1066,40 +1178,48 @@ end: } static -int lttng_userspace_probe_location_function_create_from_buffer( - const struct lttng_buffer_view *buffer, +int lttng_userspace_probe_location_function_create_from_payload( + struct lttng_payload_view *view, struct lttng_userspace_probe_location **location) { struct lttng_userspace_probe_location_function_comm *location_function_comm; const char *function_name_src, *binary_path_src; char *function_name = NULL, *binary_path = NULL; int ret = 0; + size_t expected_size; + struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view); - assert(buffer); - assert(buffer->data); assert(location); + if (view->buffer.size < sizeof(*location_function_comm)) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + location_function_comm = - (struct lttng_userspace_probe_location_function_comm *) buffer->data; + (typeof(location_function_comm)) view->buffer.data; - const size_t expected_size = sizeof(*location_function_comm) + + expected_size = sizeof(*location_function_comm) + location_function_comm->function_name_len + location_function_comm->binary_path_len; - if (buffer->size < expected_size) { + if (view->buffer.size < expected_size) { ret = -LTTNG_ERR_INVALID; goto end; } - function_name_src = buffer->data + sizeof(*location_function_comm); + function_name_src = view->buffer.data + sizeof(*location_function_comm); binary_path_src = function_name_src + location_function_comm->function_name_len; - if (function_name_src[location_function_comm->function_name_len - 1] != '\0') { + if (!lttng_buffer_view_contains_string(&view->buffer, function_name_src, + location_function_comm->function_name_len)) { ret = -LTTNG_ERR_INVALID; goto end; } - if (binary_path_src[location_function_comm->binary_path_len - 1] != '\0') { + + if (!lttng_buffer_view_contains_string(&view->buffer, binary_path_src, + location_function_comm->binary_path_len)) { ret = -LTTNG_ERR_INVALID; goto end; } @@ -1107,12 +1227,14 @@ int lttng_userspace_probe_location_function_create_from_buffer( function_name = lttng_strndup(function_name_src, LTTNG_SYMBOL_NAME_LEN); if (!function_name) { PERROR("lttng_strndup"); + ret = -LTTNG_ERR_NOMEM; goto end; } binary_path = lttng_strndup(binary_path_src, LTTNG_PATH_MAX); if (!binary_path) { PERROR("lttng_strndup"); + ret = -LTTNG_ERR_NOMEM; goto end; } @@ -1123,57 +1245,78 @@ int lttng_userspace_probe_location_function_create_from_buffer( goto end; } + ret = lttng_userspace_probe_location_function_set_binary_fd_handle( + *location, binary_fd_handle); + if (ret) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + ret = (int) expected_size; end: + fd_handle_put(binary_fd_handle); free(function_name); free(binary_path); return ret; } static -int lttng_userspace_probe_location_tracepoint_create_from_buffer( - const struct lttng_buffer_view *buffer, +int lttng_userspace_probe_location_tracepoint_create_from_payload( + struct lttng_payload_view *view, struct lttng_userspace_probe_location **location) { struct lttng_userspace_probe_location_tracepoint_comm *location_tracepoint_comm; const char *probe_name_src, *provider_name_src, *binary_path_src; char *probe_name = NULL, *provider_name = NULL, *binary_path = NULL; int ret = 0; + size_t expected_size; + struct fd_handle *binary_fd_handle = lttng_payload_view_pop_fd_handle(view); - assert(buffer); - assert(buffer->data); assert(location); + if (!binary_fd_handle) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + + if (view->buffer.size < sizeof(*location_tracepoint_comm)) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + location_tracepoint_comm = - (struct lttng_userspace_probe_location_tracepoint_comm *) buffer->data; + (typeof(location_tracepoint_comm)) view->buffer.data; - const size_t expected_size = sizeof(*location_tracepoint_comm) + + expected_size = sizeof(*location_tracepoint_comm) + location_tracepoint_comm->probe_name_len + location_tracepoint_comm->provider_name_len + location_tracepoint_comm->binary_path_len; - if (buffer->size < expected_size) { + if (view->buffer.size < expected_size) { ret = -LTTNG_ERR_INVALID; goto end; } - probe_name_src = buffer->data + sizeof(*location_tracepoint_comm); + probe_name_src = view->buffer.data + sizeof(*location_tracepoint_comm); provider_name_src = probe_name_src + location_tracepoint_comm->probe_name_len; binary_path_src = provider_name_src + location_tracepoint_comm->provider_name_len; - if (probe_name_src[location_tracepoint_comm->probe_name_len - 1] != '\0') { + if (!lttng_buffer_view_contains_string(&view->buffer, probe_name_src, + location_tracepoint_comm->probe_name_len)) { ret = -LTTNG_ERR_INVALID; goto end; } - if (provider_name_src[location_tracepoint_comm->provider_name_len - 1] != '\0') { + if (!lttng_buffer_view_contains_string(&view->buffer, provider_name_src, + location_tracepoint_comm->provider_name_len)) { ret = -LTTNG_ERR_INVALID; goto end; } - if (binary_path_src[location_tracepoint_comm->binary_path_len - 1] != '\0') { + if (!lttng_buffer_view_contains_string(&view->buffer, binary_path_src, + location_tracepoint_comm->binary_path_len)) { ret = -LTTNG_ERR_INVALID; goto end; } @@ -1202,8 +1345,16 @@ int lttng_userspace_probe_location_tracepoint_create_from_buffer( goto end; } + ret = lttng_userspace_probe_location_tracepoint_set_binary_fd_handle( + *location, binary_fd_handle); + if (ret) { + ret = -LTTNG_ERR_INVALID; + goto end; + } + ret = (int) expected_size; end: + fd_handle_put(binary_fd_handle); free(probe_name); free(provider_name); free(binary_path); @@ -1211,25 +1362,23 @@ end: } static -int lttng_userspace_probe_location_lookup_method_create_from_buffer( - struct lttng_buffer_view *buffer, +int lttng_userspace_probe_location_lookup_method_create_from_payload( + struct lttng_payload_view *view, struct lttng_userspace_probe_location_lookup_method **lookup_method) { int ret; struct lttng_userspace_probe_location_lookup_method_comm *lookup_comm; enum lttng_userspace_probe_location_lookup_method_type type; - assert(buffer); - assert(buffer->data); + assert(view); assert(lookup_method); - if (buffer->size < sizeof(*lookup_comm)) { + if (view->buffer.size < sizeof(*lookup_comm)) { ret = -LTTNG_ERR_INVALID; goto end; } - lookup_comm = (struct lttng_userspace_probe_location_lookup_method_comm *) - buffer->data; + lookup_comm = (typeof(lookup_comm)) view->buffer.data; type = (enum lttng_userspace_probe_location_lookup_method_type) lookup_comm->type; switch (type) { @@ -1263,42 +1412,42 @@ end: } LTTNG_HIDDEN -int lttng_userspace_probe_location_create_from_buffer( - const struct lttng_buffer_view *buffer, +int lttng_userspace_probe_location_create_from_payload( + struct lttng_payload_view *view, struct lttng_userspace_probe_location **location) { struct lttng_userspace_probe_location_lookup_method *lookup_method; - struct lttng_userspace_probe_location_comm *probe_location_comm; enum lttng_userspace_probe_location_type type; - struct lttng_buffer_view lookup_method_view; int consumed = 0; int ret; + struct lttng_userspace_probe_location_comm *probe_location_comm; + struct lttng_payload_view probe_location_comm_view = + lttng_payload_view_from_view( + view, 0, sizeof(*probe_location_comm)); - - assert(buffer); - assert(buffer->data); + assert(view); assert(location); lookup_method = NULL; - if (buffer->size <= sizeof(*probe_location_comm)) { + if (!lttng_payload_view_is_valid(&probe_location_comm_view)) { ret = -LTTNG_ERR_INVALID; goto end; } - probe_location_comm = - (struct lttng_userspace_probe_location_comm *) buffer->data; + probe_location_comm = (typeof(probe_location_comm)) probe_location_comm_view.buffer.data; type = (enum lttng_userspace_probe_location_type) probe_location_comm->type; consumed += sizeof(*probe_location_comm); switch (type) { case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION: { - struct lttng_buffer_view view = lttng_buffer_view_from_view( - buffer, consumed, buffer->size - consumed); + struct lttng_payload_view location_view = + lttng_payload_view_from_view( + view, consumed, -1); - ret = lttng_userspace_probe_location_function_create_from_buffer( - &view, location); + ret = lttng_userspace_probe_location_function_create_from_payload( + &location_view, location); if (ret < 0) { goto end; } @@ -1306,11 +1455,11 @@ int lttng_userspace_probe_location_create_from_buffer( } case LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT: { - struct lttng_buffer_view view = lttng_buffer_view_from_view( - buffer, consumed, buffer->size - consumed); + struct lttng_payload_view location_view = + lttng_payload_view_from_view(view, consumed, -1); - ret = lttng_userspace_probe_location_tracepoint_create_from_buffer( - &view, location); + ret = lttng_userspace_probe_location_tracepoint_create_from_payload( + &location_view, location); if (ret < 0) { goto end; } @@ -1322,15 +1471,19 @@ int lttng_userspace_probe_location_create_from_buffer( } consumed += ret; - if (buffer->size <= consumed) { + if (view->buffer.size <= consumed) { ret = -LTTNG_ERR_INVALID; goto end; } - lookup_method_view = lttng_buffer_view_from_view(buffer, consumed, - buffer->size - consumed); - ret = lttng_userspace_probe_location_lookup_method_create_from_buffer( - &lookup_method_view, &lookup_method); + { + struct lttng_payload_view lookup_method_view = + lttng_payload_view_from_view( + view, consumed, -1); + + ret = lttng_userspace_probe_location_lookup_method_create_from_payload( + &lookup_method_view, &lookup_method); + } if (ret < 0) { ret = -LTTNG_ERR_INVALID; goto end; @@ -1344,9 +1497,10 @@ end: return ret; } -LTTNG_HIDDEN -int lttng_userspace_probe_location_function_set_binary_fd( - struct lttng_userspace_probe_location *location, int binary_fd) +static +int lttng_userspace_probe_location_function_set_binary_fd_handle( + struct lttng_userspace_probe_location *location, + struct fd_handle *binary_fd) { int ret = 0; struct lttng_userspace_probe_location_function *function_location; @@ -1356,23 +1510,16 @@ int lttng_userspace_probe_location_function_set_binary_fd( function_location = container_of(location, struct lttng_userspace_probe_location_function, parent); - if (function_location->binary_fd >= 0) { - ret = close(function_location->binary_fd); - if (ret) { - PERROR("close"); - ret = -LTTNG_ERR_INVALID; - goto end; - } - } - - function_location->binary_fd = binary_fd; -end: + fd_handle_put(function_location->binary_fd_handle); + fd_handle_get(binary_fd); + function_location->binary_fd_handle = binary_fd; return ret; } -LTTNG_HIDDEN -int lttng_userspace_probe_location_tracepoint_set_binary_fd( - struct lttng_userspace_probe_location *location, int binary_fd) +static +int lttng_userspace_probe_location_tracepoint_set_binary_fd_handle( + struct lttng_userspace_probe_location *location, + struct fd_handle *binary_fd) { int ret = 0; struct lttng_userspace_probe_location_tracepoint *tracepoint_location; @@ -1382,17 +1529,9 @@ int lttng_userspace_probe_location_tracepoint_set_binary_fd( tracepoint_location = container_of(location, struct lttng_userspace_probe_location_tracepoint, parent); - if (tracepoint_location->binary_fd >= 0) { - ret = close(tracepoint_location->binary_fd); - if (ret) { - PERROR("close"); - ret = -LTTNG_ERR_INVALID; - goto end; - } - } - - tracepoint_location->binary_fd = binary_fd; -end: + fd_handle_put(tracepoint_location->binary_fd_handle); + fd_handle_get(binary_fd); + tracepoint_location->binary_fd_handle = binary_fd; return ret; } @@ -1476,7 +1615,7 @@ int lttng_userspace_probe_location_function_flatten( flat_probe.function_name = flat_probe_start + sizeof(flat_probe); flat_probe.binary_path = flat_probe.function_name + function_name_len; - flat_probe.binary_fd = -1; + flat_probe.binary_fd_handle = NULL; ret = lttng_dynamic_buffer_append(buffer, &flat_probe, sizeof(flat_probe)); if (ret) { @@ -1611,7 +1750,7 @@ int lttng_userspace_probe_location_tracepoint_flatten( flat_probe.probe_name = flat_probe_start + sizeof(flat_probe); flat_probe.provider_name = flat_probe.probe_name + probe_name_len; flat_probe.binary_path = flat_probe.provider_name + provider_name_len; - flat_probe.binary_fd = -1; + flat_probe.binary_fd_handle = NULL; ret = lttng_dynamic_buffer_append(buffer, &flat_probe, sizeof(flat_probe)); if (ret) { goto end; @@ -1722,3 +1861,58 @@ struct lttng_userspace_probe_location *lttng_userspace_probe_location_copy( err: 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 is_equal = false; + + if (!a || !b) { + goto end; + } + + if (a == b) { + is_equal = true; + goto end; + } + + if (a->type != b->type) { + goto end; + } + + is_equal = true; +end: + 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 is_equal = false; + + if (!a || !b) { + goto end; + } + + if (a == b) { + is_equal = true; + goto end; + } + + if (!lttng_userspace_probe_location_lookup_method_is_equal( + a->lookup_method, b->lookup_method)) { + goto end; + } + + if (a->type != b->type) { + goto end; + } + + is_equal = a->equal ? a->equal(a, b) : true; +end: + return is_equal; +}