userspace-probe: implement is_equal
authorJonathan Rajotte <jonathan.rajotte-julien@efficios.com>
Fri, 31 Jan 2020 21:05:16 +0000 (16:05 -0500)
committerJérémie Galarneau <jeremie.galarneau@efficios.com>
Mon, 27 Jul 2020 20:30:15 +0000 (16:30 -0400)
Signed-off-by: Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
Change-Id: I11ba6c607f5b4b4556dd9048a140a7b0cdda7e4f

include/lttng/userspace-probe-internal.h
src/common/userspace-probe.c

index 8287954931791e21bf3b7e0e5f595c91e46f605d..fe356b9747d351cbe8229e37be8db04c8f05d20b 100644 (file)
 #include <common/dynamic-buffer.h>
 #include <common/buffer-view.h>
 
+typedef bool (*userspace_probe_location_equal_cb)(
+               const struct lttng_userspace_probe_location *a,
+               const struct lttng_userspace_probe_location *b);
+
 /*
  * No elf-specific comm structure is defined since no elf-specific payload is
  * currently needed.
@@ -79,6 +83,7 @@ struct lttng_userspace_probe_location_tracepoint_comm {
 struct lttng_userspace_probe_location {
        enum lttng_userspace_probe_location_type type;
        struct lttng_userspace_probe_location_lookup_method *lookup_method;
+       userspace_probe_location_equal_cb equal;
 };
 
 struct lttng_userspace_probe_location_function {
@@ -142,4 +147,14 @@ LTTNG_HIDDEN
 struct lttng_userspace_probe_location *lttng_userspace_probe_location_copy(
                const struct lttng_userspace_probe_location *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);
+
+LTTNG_HIDDEN
+bool lttng_userspace_probe_location_is_equal(
+               const struct lttng_userspace_probe_location *a,
+               const struct lttng_userspace_probe_location *b);
+
 #endif /* LTTNG_USERSPACE_PROBE_INTERNAL_H */
index 508c9e8d4480a8a99216e7a3792a6555dd534d3f..fe11e3b5018c26d6136067e84bd1d7f7185ee17f 100644 (file)
@@ -6,12 +6,15 @@
  */
 
 #include <assert.h>
+#include <common/compat/string.h>
 #include <common/error.h>
 #include <common/macros.h>
-#include <common/compat/string.h>
 #include <fcntl.h>
 #include <lttng/constant.h>
 #include <lttng/userspace-probe-internal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/unistd.h>
 
 enum lttng_userspace_probe_location_lookup_method_type
 lttng_userspace_probe_location_lookup_method_get_type(
@@ -144,6 +147,86 @@ 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, b->binary_fd);
+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,
@@ -192,6 +275,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:
@@ -206,6 +290,42 @@ 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, b->binary_fd);
+
+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,
@@ -261,6 +381,7 @@ 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:
@@ -1711,3 +1832,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;
+}
This page took 0.039152 seconds and 4 git commands to generate.