X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Fuserspace-probe.c;h=4cc881025656cb582ffbcbf701051539ed564809;hb=d3a684eebfe788a7527368d65d7f020bdd1e61d9;hp=6331ff13574e9f03e14a4dc426284fe97390e526;hpb=cc8313098a2e4e28b0bae7539dd234d8b9fe6211;p=lttng-tools.git diff --git a/src/common/userspace-probe.c b/src/common/userspace-probe.c index 6331ff135..4cc881025 100644 --- a/src/common/userspace-probe.c +++ b/src/common/userspace-probe.c @@ -1,18 +1,8 @@ /* - * 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 @@ -154,6 +144,41 @@ void lttng_userspace_probe_location_destroy( } } +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); + + /* The binary_fd is not checked since it does not hold "immutable" + * information. + */ + + 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 = true; +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, @@ -202,6 +227,7 @@ lttng_userspace_probe_location_function_create_no_check(const char *binary_path, 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: @@ -216,6 +242,43 @@ 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); + + /* The binary_fd is not checked since it does not hold "immutable" + * information. + */ + + 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 = true; +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, @@ -271,11 +334,13 @@ lttng_userspace_probe_location_tracepoint_create_no_check(const char *binary_pat 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"); @@ -404,7 +469,7 @@ lttng_userspace_probe_location_function_copy( struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL; const char *binary_path = NULL; const char *function_name = NULL; - int fd; + int fd, new_fd; assert(location); assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION); @@ -423,8 +488,14 @@ lttng_userspace_probe_location_function_copy( } /* Duplicate the binary fd */ - fd = dup(lttng_userspace_probe_location_function_get_binary_fd(location)); + fd = lttng_userspace_probe_location_function_get_binary_fd(location); if (fd == -1) { + ERR("Error getting file descriptor to binary"); + goto error; + } + + new_fd = dup(fd); + if (new_fd == -1) { PERROR("Error duplicating file descriptor to binary"); goto error; } @@ -456,7 +527,7 @@ lttng_userspace_probe_location_function_copy( } /* 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(new_location, new_fd) < 0) { goto destroy_probe_location; } @@ -467,7 +538,7 @@ destroy_probe_location: destroy_lookup_method: lttng_userspace_probe_location_lookup_method_destroy(lookup_method); close_fd: - if (close(fd) < 0) { + if (close(new_fd) < 0) { PERROR("Error closing duplicated file descriptor in error path"); } error: @@ -486,7 +557,7 @@ lttng_userspace_probe_location_tracepoint_copy( const char *binary_path = NULL; const char *probe_name = NULL; const char *provider_name = NULL; - int fd; + int fd, new_fd; assert(location); assert(location->type == LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT); @@ -511,8 +582,14 @@ lttng_userspace_probe_location_tracepoint_copy( } /* Duplicate the binary fd */ - fd = dup(lttng_userspace_probe_location_tracepoint_get_binary_fd(location)); + fd = lttng_userspace_probe_location_tracepoint_get_binary_fd(location); if (fd == -1) { + ERR("Error getting file descriptor to binary"); + goto error; + } + + new_fd = dup(fd); + if (new_fd == -1) { PERROR("Error duplicating file descriptor to binary"); goto error; } @@ -544,7 +621,7 @@ lttng_userspace_probe_location_tracepoint_copy( } /* 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(new_location, new_fd) < 0) { goto destroy_probe_location; } @@ -555,7 +632,7 @@ destroy_probe_location: destroy_lookup_method: lttng_userspace_probe_location_lookup_method_destroy(lookup_method); close_fd: - if (close(fd) < 0) { + if (close(new_fd) < 0) { PERROR("Error closing duplicated file descriptor in error path"); } error: @@ -1708,3 +1785,70 @@ struct lttng_userspace_probe_location *lttng_userspace_probe_location_copy( err: return new_location; } + +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->type != b->type) { + goto end; + } + + if (a == b) { + is_equal = true; + goto end; + } + + is_equal = a->equal ? a->equal(a, b) : true; +end: + return is_equal; +} + +LTTNG_HIDDEN +int lttng_userspace_probe_location_set_binary_fd( + struct lttng_userspace_probe_location *location, int fd) +{ + int ret = 0; + const struct lttng_userspace_probe_location_lookup_method *lookup = NULL; + /* + * Set the file descriptor received from the client through the unix + * socket in the probe location. + */ + lookup = lttng_userspace_probe_location_get_lookup_method(location); + if (!lookup) { + ret = LTTNG_ERR_PROBE_LOCATION_INVAL; + goto end; + } + + /* + * From the kernel tracer's perspective, all userspace probe event types + * are all the same: a file and an offset. + */ + switch (lttng_userspace_probe_location_lookup_method_get_type(lookup)) { + case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF: + ret = lttng_userspace_probe_location_function_set_binary_fd( + location, fd); + break; + case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT: + ret = lttng_userspace_probe_location_tracepoint_set_binary_fd( + location, fd); + break; + default: + ret = LTTNG_ERR_PROBE_LOCATION_INVAL; + goto end; + } + + if (ret) { + ret = LTTNG_ERR_PROBE_LOCATION_INVAL; + goto end; + } +end: + return ret; +}