libbpf: auto-resolve programs/libraries when necessary for uprobes

bpf_program__attach_uprobe_opts() requires a binary_path argument
specifying binary to instrument.  Supporting simply specifying
"libc.so.6" or "foo" should be possible too.

Library search checks LD_LIBRARY_PATH, then /usr/lib64, /usr/lib.
This allows users to run BPF programs prefixed with
LD_LIBRARY_PATH=/path2/lib while still searching standard locations.
Similarly for non .so files, we check PATH and /usr/bin, /usr/sbin.

Path determination will be useful for auto-attach of BPF uprobe programs
using SEC() definition.

Signed-off-by: Alan Maguire <alan.maguire@oracle.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Link: https://lore.kernel.org/bpf/1648654000-21758-2-git-send-email-alan.maguire@oracle.com

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 809fe20..ba6b613 100644 (file)
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -10517,6 +10517,46 @@ static int perf_event_uprobe_open_legacy(const char *probe_name, bool retprobe,
        return pfd;
 }
 
+/* Get full path to program/shared library. */
+static int resolve_full_path(const char *file, char *result, size_t result_sz)
+{
+       const char *search_paths[2];
+       int i;
+
+       if (strstr(file, ".so")) {
+               search_paths[0] = getenv("LD_LIBRARY_PATH");
+               search_paths[1] = "/usr/lib64:/usr/lib";
+       } else {
+               search_paths[0] = getenv("PATH");
+               search_paths[1] = "/usr/bin:/usr/sbin";
+       }
+
+       for (i = 0; i < ARRAY_SIZE(search_paths); i++) {
+               const char *s;
+
+               if (!search_paths[i])
+                       continue;
+               for (s = search_paths[i]; s != NULL; s = strchr(s, ':')) {
+                       char *next_path;
+                       int seg_len;
+
+                       if (s[0] == ':')
+                               s++;
+                       next_path = strchr(s, ':');
+                       seg_len = next_path ? next_path - s : strlen(s);
+                       if (!seg_len)
+                               continue;
+                       snprintf(result, result_sz, "%.*s/%s", seg_len, s, file);
+                       /* ensure it is an executable file/link */
+                       if (access(result, R_OK | X_OK) < 0)
+                               continue;
+                       pr_debug("resolved '%s' to '%s'\n", file, result);
+                       return 0;
+               }
+       }
+       return -ENOENT;
+}
+
 LIBBPF_API struct bpf_link *
 bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,
                                const char *binary_path, size_t func_offset,
@@ -10524,6 +10564,7 @@ bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,
 {
        DECLARE_LIBBPF_OPTS(bpf_perf_event_opts, pe_opts);
        char errmsg[STRERR_BUFSIZE], *legacy_probe = NULL;
+       char full_binary_path[PATH_MAX];
        struct bpf_link *link;
        size_t ref_ctr_off;
        int pfd, err;
@@ -10536,12 +10577,23 @@ bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,
        ref_ctr_off = OPTS_GET(opts, ref_ctr_offset, 0);
        pe_opts.bpf_cookie = OPTS_GET(opts, bpf_cookie, 0);
 
+       if (binary_path && !strchr(binary_path, '/')) {
+               err = resolve_full_path(binary_path, full_binary_path,
+                                       sizeof(full_binary_path));
+               if (err) {
+                       pr_warn("prog '%s': failed to resolve full path for '%s'\n",
+                               prog->name, binary_path);
+                       return libbpf_err_ptr(err);
+               }
+               binary_path = full_binary_path;
+       }
+
        legacy = determine_uprobe_perf_type() < 0;
        if (!legacy) {
                pfd = perf_event_open_probe(true /* uprobe */, retprobe, binary_path,
                                            func_offset, pid, ref_ctr_off);
        } else {
-               char probe_name[512];
+               char probe_name[PATH_MAX + 64];
 
                if (ref_ctr_off)
                        return libbpf_err_ptr(-EINVAL);