bpf: Add cookie support to programs attached with kprobe multi link

Adding support to call bpf_get_attach_cookie helper from
kprobe programs attached with kprobe multi link.

The cookie is provided by array of u64 values, where each
value is paired with provided function address or symbol
with the same array index.

When cookie array is provided it's sorted together with
addresses (check bpf_kprobe_multi_cookie_swap). This way
we can find cookie based on the address in
bpf_get_attach_cookie helper.

Suggested-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20220316122419.933957-7-jolsa@kernel.org

diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h
index d77f47a..7604e7d 100644 (file)
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -1487,6 +1487,7 @@ union bpf_attr {
                                __u32           cnt;
                                __aligned_u64   syms;
                                __aligned_u64   addrs;
+                               __aligned_u64   cookies;
                        } kprobe_multi;
                };
        } link_create;

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index b8bb67e..cdaa115 100644 (file)
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -4261,7 +4261,7 @@ static int tracing_bpf_link_attach(const union bpf_attr *attr, bpfptr_t uattr,
        return -EINVAL;
 }
 
-#define BPF_LINK_CREATE_LAST_FIELD link_create.kprobe_multi.addrs
+#define BPF_LINK_CREATE_LAST_FIELD link_create.kprobe_multi.cookies
 static int link_create(union bpf_attr *attr, bpfptr_t uattr)
 {
        enum bpf_prog_type ptype;

diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c
index 0e7f8c9..9a7b6be 100644 (file)
--- a/kernel/trace/bpf_trace.c
+++ b/kernel/trace/bpf_trace.c
@@ -18,6 +18,8 @@
 #include <linux/btf_ids.h>
 #include <linux/bpf_lsm.h>
 #include <linux/fprobe.h>
+#include <linux/bsearch.h>
+#include <linux/sort.h>
 
 #include <net/bpf_sk_storage.h>
 
@@ -78,6 +80,7 @@ u64 bpf_get_stack(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
 static int bpf_btf_printf_prepare(struct btf_ptr *ptr, u32 btf_ptr_size,
                                  u64 flags, const struct btf **btf,
                                  s32 *btf_id);
+static u64 bpf_kprobe_multi_cookie(struct bpf_run_ctx *ctx, u64 ip);
 
 /**
  * trace_call_bpf - invoke BPF program
@@ -1050,6 +1053,18 @@ static const struct bpf_func_proto bpf_get_func_ip_proto_kprobe_multi = {
        .arg1_type      = ARG_PTR_TO_CTX,
 };
 
+BPF_CALL_1(bpf_get_attach_cookie_kprobe_multi, struct pt_regs *, regs)
+{
+       return bpf_kprobe_multi_cookie(current->bpf_ctx, instruction_pointer(regs));
+}
+
+static const struct bpf_func_proto bpf_get_attach_cookie_proto_kmulti = {
+       .func           = bpf_get_attach_cookie_kprobe_multi,
+       .gpl_only       = false,
+       .ret_type       = RET_INTEGER,
+       .arg1_type      = ARG_PTR_TO_CTX,
+};
+
 BPF_CALL_1(bpf_get_attach_cookie_trace, void *, ctx)
 {
        struct bpf_trace_run_ctx *run_ctx;
@@ -1297,7 +1312,9 @@ kprobe_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
                        &bpf_get_func_ip_proto_kprobe_multi :
                        &bpf_get_func_ip_proto_kprobe;
        case BPF_FUNC_get_attach_cookie:
-               return &bpf_get_attach_cookie_proto_trace;
+               return prog->expected_attach_type == BPF_TRACE_KPROBE_MULTI ?
+                       &bpf_get_attach_cookie_proto_kmulti :
+                       &bpf_get_attach_cookie_proto_trace;
        default:
                return bpf_tracing_func_proto(func_id, prog);
        }
@@ -2203,6 +2220,13 @@ struct bpf_kprobe_multi_link {
        struct bpf_link link;
        struct fprobe fp;
        unsigned long *addrs;
+       /*
+        * The run_ctx here is used to get struct bpf_kprobe_multi_link in
+        * get_attach_cookie helper, so it can't be used to store data.
+        */
+       struct bpf_run_ctx run_ctx;
+       u64 *cookies;
+       u32 cnt;
 };
 
 static void bpf_kprobe_multi_link_release(struct bpf_link *link)
@@ -2219,6 +2243,7 @@ static void bpf_kprobe_multi_link_dealloc(struct bpf_link *link)
 
        kmulti_link = container_of(link, struct bpf_kprobe_multi_link, link);
        kvfree(kmulti_link->addrs);
+       kvfree(kmulti_link->cookies);
        kfree(kmulti_link);
 }
 
@@ -2227,10 +2252,60 @@ static const struct bpf_link_ops bpf_kprobe_multi_link_lops = {
        .dealloc = bpf_kprobe_multi_link_dealloc,
 };
 
+static void bpf_kprobe_multi_cookie_swap(void *a, void *b, int size, const void *priv)
+{
+       const struct bpf_kprobe_multi_link *link = priv;
+       unsigned long *addr_a = a, *addr_b = b;
+       u64 *cookie_a, *cookie_b;
+       unsigned long tmp1;
+       u64 tmp2;
+
+       cookie_a = link->cookies + (addr_a - link->addrs);
+       cookie_b = link->cookies + (addr_b - link->addrs);
+
+       /* swap addr_a/addr_b and cookie_a/cookie_b values */
+       tmp1 = *addr_a; *addr_a = *addr_b; *addr_b = tmp1;
+       tmp2 = *cookie_a; *cookie_a = *cookie_b; *cookie_b = tmp2;
+}
+
+static int __bpf_kprobe_multi_cookie_cmp(const void *a, const void *b)
+{
+       const unsigned long *addr_a = a, *addr_b = b;
+
+       if (*addr_a == *addr_b)
+               return 0;
+       return *addr_a < *addr_b ? -1 : 1;
+}
+
+static int bpf_kprobe_multi_cookie_cmp(const void *a, const void *b, const void *priv)
+{
+       return __bpf_kprobe_multi_cookie_cmp(a, b);
+}
+
+static u64 bpf_kprobe_multi_cookie(struct bpf_run_ctx *ctx, u64 ip)
+{
+       struct bpf_kprobe_multi_link *link;
+       unsigned long *addr;
+       u64 *cookie;
+
+       if (WARN_ON_ONCE(!ctx))
+               return 0;
+       link = container_of(ctx, struct bpf_kprobe_multi_link, run_ctx);
+       if (!link->cookies)
+               return 0;
+       addr = bsearch(&ip, link->addrs, link->cnt, sizeof(ip),
+                      __bpf_kprobe_multi_cookie_cmp);
+       if (!addr)
+               return 0;
+       cookie = link->cookies + (addr - link->addrs);
+       return *cookie;
+}
+
 static int
 kprobe_multi_link_prog_run(struct bpf_kprobe_multi_link *link,
                           struct pt_regs *regs)
 {
+       struct bpf_run_ctx *old_run_ctx;
        int err;
 
        if (unlikely(__this_cpu_inc_return(bpf_prog_active) != 1)) {
@@ -2240,7 +2315,9 @@ kprobe_multi_link_prog_run(struct bpf_kprobe_multi_link *link,
 
        migrate_disable();
        rcu_read_lock();
+       old_run_ctx = bpf_set_run_ctx(&link->run_ctx);
        err = bpf_prog_run(link->link.prog, regs);
+       bpf_reset_run_ctx(old_run_ctx);
        rcu_read_unlock();
        migrate_enable();
 
@@ -2326,9 +2403,11 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *pr
 {
        struct bpf_kprobe_multi_link *link = NULL;
        struct bpf_link_primer link_primer;
+       void __user *ucookies;
        unsigned long *addrs;
        u32 flags, cnt, size;
        void __user *uaddrs;
+       u64 *cookies = NULL;
        void __user *usyms;
        int err;
 
@@ -2368,6 +2447,19 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *pr
                        goto error;
        }
 
+       ucookies = u64_to_user_ptr(attr->link_create.kprobe_multi.cookies);
+       if (ucookies) {
+               cookies = kvmalloc(size, GFP_KERNEL);
+               if (!cookies) {
+                       err = -ENOMEM;
+                       goto error;
+               }
+               if (copy_from_user(cookies, ucookies, size)) {
+                       err = -EFAULT;
+                       goto error;
+               }
+       }
+
        link = kzalloc(sizeof(*link), GFP_KERNEL);
        if (!link) {
                err = -ENOMEM;
@@ -2387,6 +2479,21 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *pr
                link->fp.entry_handler = kprobe_multi_link_handler;
 
        link->addrs = addrs;
+       link->cookies = cookies;
+       link->cnt = cnt;
+
+       if (cookies) {
+               /*
+                * Sorting addresses will trigger sorting cookies as well
+                * (check bpf_kprobe_multi_cookie_swap). This way we can
+                * find cookie based on the address in bpf_get_attach_cookie
+                * helper.
+                */
+               sort_r(addrs, cnt, sizeof(*addrs),
+                      bpf_kprobe_multi_cookie_cmp,
+                      bpf_kprobe_multi_cookie_swap,
+                      link);
+       }
 
        err = register_fprobe_ips(&link->fp, addrs, cnt);
        if (err) {
@@ -2399,6 +2506,7 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *pr
 error:
        kfree(link);
        kvfree(addrs);
+       kvfree(cookies);
        return err;
 }
 #else /* !CONFIG_FPROBE */
@@ -2406,4 +2514,8 @@ int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *pr
 {
        return -EOPNOTSUPP;
 }
+static u64 bpf_kprobe_multi_cookie(struct bpf_run_ctx *ctx, u64 ip)
+{
+       return 0;
+}
 #endif

diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
index d77f47a..7604e7d 100644 (file)
--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
@@ -1487,6 +1487,7 @@ union bpf_attr {
                                __u32           cnt;
                                __aligned_u64   syms;
                                __aligned_u64   addrs;
+                               __aligned_u64   cookies;
                        } kprobe_multi;
                };
        } link_create;