On Thu, Sep 3, 2020 at 3:34 PM Hao Luo haoluo@google.com wrote:

Pseudo_btf_id is a type of ld_imm insn that associates a btf_id to a ksym so that further dereferences on the ksym can use the BTF info to validate accesses. Internally, when seeing a pseudo_btf_id ld insn, the verifier reads the btf_id stored in the insn[0]'s imm field and marks the dst_reg as PTR_TO_BTF_ID. The btf_id points to a VAR_KIND, which is encoded in btf_vminux by pahole. If the VAR is not of a struct type, the dst reg will be marked as PTR_TO_MEM instead of PTR_TO_BTF_ID and the mem_size is resolved to the size of the VAR's type.

From the VAR btf_id, the verifier can also read the address of the ksym's corresponding kernel var from kallsyms and use that to fill dst_reg.

Therefore, the proper functionality of pseudo_btf_id depends on (1) kallsyms and (2) the encoding of kernel global VARs in pahole, which should be available since pahole v1.18.

Signed-off-by: Hao Luo haoluo@google.com

Logic looks correct, but I have a few suggestions for naming things and verifier logs. Please see below.

include/linux/bpf_verifier.h | 4 ++ include/linux/btf.h | 15 +++++ include/uapi/linux/bpf.h | 38 ++++++++--- kernel/bpf/btf.c | 15 ----- kernel/bpf/verifier.c | 112 ++++++++++++++++++++++++++++++--- tools/include/uapi/linux/bpf.h | 38 ++++++++--- 6 files changed, 182 insertions(+), 40 deletions(-)

diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h index 53c7bd568c5d..a14063f64d96 100644 --- a/include/linux/bpf_verifier.h +++ b/include/linux/bpf_verifier.h @@ -308,6 +308,10 @@ struct bpf_insn_aux_data { u32 map_index; /* index into used_maps[] */ u32 map_off; /* offset from value base address */ };

•           struct {
  

•                   u32 pseudo_btf_id_type; /* type of pseudo_btf_id */
  

•                   u32 pseudo_btf_id_meta; /* memsize or btf_id */
  

a bit misleading names, not clear at all in the code what's in there. This section is for ldimm64 insns that are loading BTF variables, right? so how about this:

struct { u32 reg_type; union { u32 btf_id; u32 memsize; }; } btf_var;

In case someone hates non-anonymous structs, I'd still go with btf_var_reg_type, btf_var_btf_id and btf_var_memsize.

•           };
    };
    u64 map_key_state; /* constant (32 bit) key tracking for maps */
    int ctx_field_size; /* the ctx field size for load insn, maybe 0 */
  

diff --git a/include/linux/btf.h b/include/linux/btf.h index a9af5e7a7ece..592373d359b9 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -106,6 +106,21 @@ static inline bool btf_type_is_func_proto(const struct btf_type *t) return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC_PROTO; }

[...]

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index b4e9c56b8b32..3b382c080cfd 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -7398,6 +7398,24 @@ static int check_ld_imm(struct bpf_verifier_env *env, struct bpf_insn *insn) return 0; }

•   if (insn->src_reg == BPF_PSEUDO_BTF_ID) {
  

•           u32 type = aux->pseudo_btf_id_type;
  

•           u32 meta = aux->pseudo_btf_id_meta;
  

•           mark_reg_known_zero(env, regs, insn->dst_reg);
  

•           regs[insn->dst_reg].type = type;
  

•           if (type == PTR_TO_MEM) {
  

•                   regs[insn->dst_reg].mem_size = meta;
  

•           } else if (type == PTR_TO_BTF_ID) {
  

•                   regs[insn->dst_reg].btf_id = meta;
  

nit: probably worthwhile to introduce a local variable (dst_reg) to capture pointer to regs[insn->dst_reg] in this entire function. Then no reall need for type and meta local vars above, everything is going to be short and sweet.

•           } else {
  

•                   verbose(env, "bpf verifier is misconfigured\n");
  

•                   return -EFAULT;
  

•           }
  

•           return 0;
  

•   }
  

•   map = env->used_maps[aux->map_index];
    mark_reg_known_zero(env, regs, insn->dst_reg);
    regs[insn->dst_reg].map_ptr = map;
  

@@ -9284,6 +9302,74 @@ static int do_check(struct bpf_verifier_env *env) return 0; }

+/* replace pseudo btf_id with kernel symbol address */ +static int check_pseudo_btf_id(struct bpf_verifier_env *env,

•                          struct bpf_insn *insn,
  

•                          struct bpf_insn_aux_data *aux)
  

+{

•   u32 type, id = insn->imm;
  

•   const struct btf_type *t;
  

•   const char *sym_name;
  

•   u64 addr;
  

•   if (!btf_vmlinux) {
  

•           verbose(env, "%s: btf not available. verifier misconfigured.\n",
  

•                   __func__);
  

verifier logs so far hasn't used __func__ and it's not all that meaningful to users and might change due to later refactorings.

Also, in this particular case, it's not a verifier misconfiguration, but rather that the kernel doesn't have a built-in BTF, so suggest enabling CONFIG_DEBUG_INFO_BTF=y.

"kernel is missing BTF, make sure CONFIG_DEBUG_INFO_BTF=y is specified in Kconfig"

•           return -EINVAL;
  

•   }
  

•   t = btf_type_by_id(btf_vmlinux, id);
  

•   if (!t) {
  

•           verbose(env, "%s: invalid btf_id %d\n", __func__, id);
  

"ldimm64 insn specifies invalid btf_id %d"? add similar context below

•           return -ENOENT;
  

•   }
  

•   if (insn[1].imm != 0) {
  

•           verbose(env, "%s: BPF_PSEUDO_BTF_ID uses reserved fields\n",
  

•                   __func__);
  

•           return -EINVAL;
  

•   }
  

•   if (!btf_type_is_var(t)) {
  

•           verbose(env, "%s: btf_id %d isn't KIND_VAR\n", __func__, id);
  

•           return -EINVAL;
  

•   }
  

•   sym_name = btf_name_by_offset(btf_vmlinux, t->name_off);
  

•   addr = kallsyms_lookup_name(sym_name);
  

•   if (!addr) {
  

•           verbose(env, "%s: failed to find the address of symbol '%s'.\n",
  

•                   __func__, sym_name);
  

•           return -ENOENT;
  

•   }
  

[...]

@@ -9394,10 +9480,14 @@ static bool bpf_map_is_cgroup_storage(struct bpf_map *map) map->map_type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE); }

-/* look for pseudo eBPF instructions that access map FDs and

• • replace them with actual map pointers

+/* find and rewrite pseudo imm in ld_imm64 instructions:

• • 1. if it accesses map FD, replace it with actual map pointer.
• • 2. if it accesses btf_id of a VAR, replace it with pointer to the var.
• • NOTE: btf_vmlinux is required for converting pseudo btf_id.
  */

-static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env) +static int replace_pseudo_imm_with_ptr(struct bpf_verifier_env *env)

nit: I'd call this something like "resolve_pseudo_ldimm64" instead. ptr here is an implementation detail of map pointers ldimm64 and doesn't even match what we are doing for pseudo_btf_id

{ struct bpf_insn *insn = env->prog->insnsi; int insn_cnt = env->prog->len; @@ -9438,6 +9528,14 @@ static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env) /* valid generic load 64-bit imm */ goto next_insn;

•                   if (insn[0].src_reg == BPF_PSEUDO_BTF_ID) {
  

•                           aux = &env->insn_aux_data[i];
  

•                           err = check_pseudo_btf_id(env, insn, aux);
  

•                           if (err)
  

•                                   return err;
  

•                           goto next_insn;
  

•                   }
  

•                   /* In final convert_pseudo_ld_imm64() step, this is
                     * converted into regular 64-bit imm load insn.
                     */
  

[...]

Will follow the libbpf logging convention. Thanks for the suggestions.

On Fri, Sep 4, 2020 at 12:34 PM Andrii Nakryiko andrii.nakryiko@gmail.com wrote:

On Thu, Sep 3, 2020 at 3:34 PM Hao Luo haoluo@google.com wrote:

...

If a ksym is defined with a type, libbpf will try to find the ksym's btf information from kernel btf. If a valid btf entry for the ksym is found, libbpf can pass in the found btf id to the verifier, which validates the ksym's type and value.

Typeless ksyms (i.e. those defined as 'void') will not have such btf_id, but it has the symbol's address (read from kallsyms) and its value is treated as a raw pointer.

Signed-off-by: Hao Luo haoluo@google.com

Logic looks correct, but I have complaints about libbpf logging consistency, please see suggestions below.

...

tools/lib/bpf/libbpf.c | 116 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 102 insertions(+), 14 deletions(-)

[...]

...

@@ -3119,6 +3130,8 @@ static int bpf_object__collect_externs(struct bpf_object *obj) vt->type = int_btf_id; vs->offset = off; vs->size = sizeof(int);

•                   pr_debug("ksym var_secinfo: var '%s', type #%d, size %d, offset %d\n",
  

•                            ext->name, vt->type, vs->size, vs->offset);
  

debug leftover?

I was thinking we should leave a debug message when some entries in BTF are modified. It's probably unnecessary, as I'm thinking of it right now. I will remove this in v3.

...

            }
            sec->size = off;
    }

@@ -5724,8 +5737,13 @@ bpf_program__relocate(struct bpf_program *prog, struct bpf_object *obj) insn[0].imm = obj->maps[obj->kconfig_map_idx].fd; insn[1].imm = ext->kcfg.data_off; } else /* EXT_KSYM */ {

•                           insn[0].imm = (__u32)ext->ksym.addr;
  

•                           insn[1].imm = ext->ksym.addr >> 32;
  

•                           if (ext->ksym.type_id) { /* typed ksyms */
  

•                                   insn[0].src_reg = BPF_PSEUDO_BTF_ID;
  

•                                   insn[0].imm = ext->ksym.vmlinux_btf_id;
  

•                           } else { /* typeless ksyms */
  

•                                   insn[0].imm = (__u32)ext->ksym.addr;
  

•                                   insn[1].imm = ext->ksym.addr >> 32;
  

•                           }
                    }
                    break;
            case RELO_CALL:
  

@@ -6462,10 +6480,72 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj) return err; }

+static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) +{

•   struct extern_desc *ext;
  

•   int i, id;
  

•   if (!obj->btf_vmlinux) {
  

•           pr_warn("support of typed ksyms needs kernel btf.\n");
  

•           return -ENOENT;
  

•   }
  

This check shouldn't be needed, you'd either successfully load btf_vmlinux by now or will fail earlier, because BTF is required but not found.

...

•   for (i = 0; i < obj->nr_extern; i++) {
  

•           const struct btf_type *targ_var, *targ_type;
  

•           __u32 targ_type_id, local_type_id;
  

•           int ret;
  

•           ext = &obj->externs[i];
  

•           if (ext->type != EXT_KSYM || !ext->ksym.type_id)
  

•                   continue;
  

•           id = btf__find_by_name_kind(obj->btf_vmlinux, ext->name,
  

•                                       BTF_KIND_VAR);
  

•           if (id <= 0) {
  

•                   pr_warn("no btf entry for ksym '%s' in vmlinux.\n",
  

•                           ext->name);
  

please try to stick to consistent style of comments:

"extern (ksym) '%s': failed to find BTF ID in vmlinux BTF" or something like that

...

•                   return -ESRCH;
  

•           }
  

•           /* find target type_id */
  

•           targ_var = btf__type_by_id(obj->btf_vmlinux, id);
  

•           targ_type = skip_mods_and_typedefs(obj->btf_vmlinux,
  

•                                              targ_var->type,
  

•                                              &targ_type_id);
  

•           /* find local type_id */
  

•           local_type_id = ext->ksym.type_id;
  

•           ret = bpf_core_types_are_compat(obj->btf_vmlinux, targ_type_id,
  

•                                           obj->btf, local_type_id);
  

you reversed the order, it's always local btf/id, then target btf/id.

...

•           if (ret <= 0) {
  

•                   const struct btf_type *local_type;
  

•                   const char *targ_name, *local_name;
  

•                   local_type = btf__type_by_id(obj->btf, local_type_id);
  

•                   targ_name = btf__name_by_offset(obj->btf_vmlinux,
  

•                                                   targ_type->name_off);
  

•                   local_name = btf__name_by_offset(obj->btf,
  

•                                                    local_type->name_off);
  

it's a bit unfortunate that we get the name of an already resolved type, because if you have a typedef to anon struct, this will give you an empty string. I don't know how much of a problem that would be, so I think it's fine to leave it as is, and fix it if it's a problem in practice.

...

•                   pr_warn("ksym '%s' expects type '%s' (vmlinux_btf_id: #%d), "
  

•                           "but got '%s' (btf_id: #%d)\n", ext->name,
  

•                           targ_name, targ_type_id, local_name, local_type_id);
  

same thing, please stay consistent in logging format. Check bpf_core_dump_spec() for how BTF type info is usually emitted throughout libbpf:

"extern (ksym): incompatible types, expected [%d] %s %s, but kernel has [%d] %s %s\n"

there is a btf_kind_str() helper to resolve kind to a string representation.

...

•                   return -EINVAL;
  

•           }
  

•           ext->is_set = true;
  

•           ext->ksym.vmlinux_btf_id = id;
  

•           pr_debug("extern (ksym) %s=vmlinux_btf_id(#%d)\n", ext->name, id);
  

"extern (ksym) '%s': resolved to [%d] %s %s\n", similar to above suggestion. This "[%d]" format is very consistently used for BTF IDs throughout, so it will be familiar and recognizable for people that had to deal with this in libbpf logs.

...

•   }
  

•   return 0;
  

+}

static int bpf_object__resolve_externs(struct bpf_object *obj, const char *extra_kconfig) {

•   bool need_config = false, need_kallsyms = false;
  

•   bool need_kallsyms = false, need_vmlinux_btf = false;
  

•   bool need_config = false;
  

nit: doesn't make sense to change the existing source code line at all. Just add `bool need_vmlinux_btf = false;` on a new line? Or we can split all these bools into 3 separate lines, if you prefer.

...

    struct extern_desc *ext;
    void *kcfg_data = NULL;
    int err, i;

[...]

On Thu, Sep 3, 2020 at 3:35 PM Hao Luo haoluo@google.com wrote:

Selftests for typed ksyms. Tests two types of ksyms: one is a struct, the other is a plain int. This tests two paths in the kernel. Struct ksyms will be converted into PTR_TO_BTF_ID by the verifier while int typed ksyms will be converted into PTR_TO_MEM.

Signed-off-by: Hao Luo haoluo@google.com

.../testing/selftests/bpf/prog_tests/ksyms.c | 31 +++------ .../selftests/bpf/prog_tests/ksyms_btf.c | 63 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_btf.c | 23 +++++++ tools/testing/selftests/bpf/trace_helpers.c | 26 ++++++++ tools/testing/selftests/bpf/trace_helpers.h | 4 ++ 5 files changed, 123 insertions(+), 24 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_btf.c create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_btf.c

[...]

diff --git a/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c b/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c new file mode 100644 index 000000000000..7b6846342449 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2020 Google */

+#include <test_progs.h> +#include <bpf/libbpf.h> +#include <bpf/btf.h> +#include "test_ksyms_btf.skel.h"

+static int duration;

+void test_ksyms_btf(void) +{

•   __u64 runqueues_addr, bpf_prog_active_addr;
  

•   struct test_ksyms_btf *skel;
  

•   struct test_ksyms_btf__data *data;
  

•   struct btf *btf;
  

•   int percpu_datasec;
  

•   int err;
  

•   err = kallsyms_find("runqueues", &runqueues_addr);
  

•   if (CHECK(err == -ENOENT, "kallsyms_fopen", "failed to open: %d\n", errno))
  

•           return;
  

•   if (CHECK(err == -EINVAL, "ksym_find", "symbol 'runqueues' not found\n"))
  

•           return;
  

•   err = kallsyms_find("bpf_prog_active", &bpf_prog_active_addr);
  

•   if (CHECK(err == -EINVAL, "ksym_find", "symbol 'bpf_prog_active' not found\n"))
  

•           return;
  

•   btf = libbpf_find_kernel_btf();
  

•   if (CHECK(IS_ERR(btf), "btf_exists", "failed to load kernel BTF: %ld\n",
  

•             PTR_ERR(btf)))
  

•           return;
  

•   percpu_datasec = btf__find_by_name_kind(btf, ".data..percpu",
  

•                                           BTF_KIND_DATASEC);
  

•   if (percpu_datasec < 0) {
  

•           printf("%s:SKIP:no PERCPU DATASEC in kernel btf\n",
  

•                  __func__);
  

•           test__skip();
  

leaking btf here

•           return;
  

•   }
  

•   skel = test_ksyms_btf__open_and_load();
  

•   if (CHECK(!skel, "skel_open", "failed to open and load skeleton\n"))
  

here

•           return;
  

•   err = test_ksyms_btf__attach(skel);
  

•   if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
  

•           goto cleanup;
  

•   /* trigger tracepoint */
  

•   usleep(1);
  

•   data = skel->data;
  

•   CHECK(data->out__runqueues != runqueues_addr, "runqueues",
  

•         "got %llu, exp %llu\n", data->out__runqueues, runqueues_addr);
  

•   CHECK(data->out__bpf_prog_active != bpf_prog_active_addr, "bpf_prog_active",
  

•         "got %llu, exp %llu\n", data->out__bpf_prog_active, bpf_prog_active_addr);
  

u64 is not %llu on some arches, please cast explicitly to (unsigned long long)

+cleanup:

... and here (I suggest to just jump from all those locations here for cleanup)

•   test_ksyms_btf__destroy(skel);
  

+} diff --git a/tools/testing/selftests/bpf/progs/test_ksyms_btf.c b/tools/testing/selftests/bpf/progs/test_ksyms_btf.c new file mode 100644 index 000000000000..e04e31117f84 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/test_ksyms_btf.c @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2020 Google */

+#include "vmlinux.h"

+#include <bpf/bpf_helpers.h>

+__u64 out__runqueues = -1; +__u64 out__bpf_prog_active = -1;

this is addresses, not values, so _addr part would make it clearer.

+extern const struct rq runqueues __ksym; /* struct type global var. */ +extern const int bpf_prog_active __ksym; /* int type global var. */

When we add non-per-CPU kernel variables, I wonder if the fact that we have both per-CPU and global kernel variables under the same __ksym section would cause any problems and confusion? It's not clear to me if we need to have a special __percpu_ksym section or not?..

+SEC("raw_tp/sys_enter") +int handler(const void *ctx) +{

•   out__runqueues = (__u64)&runqueues;
  

•   out__bpf_prog_active = (__u64)&bpf_prog_active;
  

•   return 0;
  

+}

+char _license[] SEC("license") = "GPL"; diff --git a/tools/testing/selftests/bpf/trace_helpers.c b/tools/testing/selftests/bpf/trace_helpers.c index 4d0e913bbb22..ade555fe8294 100644 --- a/tools/testing/selftests/bpf/trace_helpers.c +++ b/tools/testing/selftests/bpf/trace_helpers.c @@ -90,6 +90,32 @@ long ksym_get_addr(const char *name) return 0; }

+/* open kallsyms and read symbol addresses on the fly. Without caching all symbols,

• • this is faster than load + find. */

+int kallsyms_find(const char *sym, unsigned long long *addr) +{

•   char type, name[500];
  

•   unsigned long long value;
  

•   int err = 0;
  

•   FILE *f;
  

•   f = fopen("/proc/kallsyms", "r");
  

•   if (!f)
  

•           return -ENOENT;
  

•   while (fscanf(f, "%llx %c %499s%*[^\n]\n", &value, &type, name) > 0) {
  

•           if (strcmp(name, sym) == 0) {
  

•                   *addr = value;
  

•                   goto out;
  

•           }
  

•   }
  

•   err = -EINVAL;
  

These error codes seem backward to me. If you fail to open /proc/kallsyms, that's an unexpected and invalid situation, so EINVAL makes a bit more sense there. But -ENOENT is clearly for cases where you didn't find what you were looking for, which is exactly this case.

+out:

•   fclose(f);
  

•   return err;
  

+}

void read_trace_pipe(void) { int trace_fd; diff --git a/tools/testing/selftests/bpf/trace_helpers.h b/tools/testing/selftests/bpf/trace_helpers.h index 25ef597dd03f..f62fdef9e589 100644 --- a/tools/testing/selftests/bpf/trace_helpers.h +++ b/tools/testing/selftests/bpf/trace_helpers.h @@ -12,6 +12,10 @@ struct ksym { int load_kallsyms(void); struct ksym *ksym_search(long key); long ksym_get_addr(const char *name);

+/* open kallsyms and find addresses on the fly, faster than load + search. */ +int kallsyms_find(const char *sym, unsigned long long *addr);

void read_trace_pipe(void);

#endif

2.28.0.526.ge36021eeef-goog

On Sun, Sep 13, 2020 at 9:58 PM Hao Luo haoluo@google.com wrote:

Thanks for taking a look, Andrii.

On Fri, Sep 4, 2020 at 12:49 PM Andrii Nakryiko andrii.nakryiko@gmail.com wrote:

...

On Thu, Sep 3, 2020 at 3:35 PM Hao Luo haoluo@google.com wrote:

...

Selftests for typed ksyms. Tests two types of ksyms: one is a struct, the other is a plain int. This tests two paths in the kernel. Struct ksyms will be converted into PTR_TO_BTF_ID by the verifier while int typed ksyms will be converted into PTR_TO_MEM.

Signed-off-by: Hao Luo haoluo@google.com

.../testing/selftests/bpf/prog_tests/ksyms.c | 31 +++------ .../selftests/bpf/prog_tests/ksyms_btf.c | 63 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_btf.c | 23 +++++++ tools/testing/selftests/bpf/trace_helpers.c | 26 ++++++++ tools/testing/selftests/bpf/trace_helpers.h | 4 ++ 5 files changed, 123 insertions(+), 24 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_btf.c create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_btf.c

[...]

...

...

+extern const struct rq runqueues __ksym; /* struct type global var. */ +extern const int bpf_prog_active __ksym; /* int type global var. */

When we add non-per-CPU kernel variables, I wonder if the fact that we have both per-CPU and global kernel variables under the same __ksym section would cause any problems and confusion? It's not clear to me if we need to have a special __percpu_ksym section or not?..

Yeah. Totally agree. I thought about this. I think a separate __percpu_ksym attribute is *probably* more clear. Not sure though. How about we introduce a "__percpu_ksym" and make it an alias to "__ksym" for now? If needed, we make an actual section for it in future.

Let's keep it in __ksym as is. Verifier will have enough insight to produce a meaningful error message, it won't be easy to misuse this feature.

...

...

+SEC("raw_tp/sys_enter") +int handler(const void *ctx) +{

•   out__runqueues = (__u64)&runqueues;
  

•   out__bpf_prog_active = (__u64)&bpf_prog_active;
  

•   return 0;
  

+}

+char _license[] SEC("license") = "GPL"; diff --git a/tools/testing/selftests/bpf/trace_helpers.c b/tools/testing/selftests/bpf/trace_helpers.c index 4d0e913bbb22..ade555fe8294 100644 --- a/tools/testing/selftests/bpf/trace_helpers.c +++ b/tools/testing/selftests/bpf/trace_helpers.c @@ -90,6 +90,32 @@ long ksym_get_addr(const char *name) return 0; }

+/* open kallsyms and read symbol addresses on the fly. Without caching all symbols,

• • this is faster than load + find. */

+int kallsyms_find(const char *sym, unsigned long long *addr) +{

•   char type, name[500];
  

•   unsigned long long value;
  

•   int err = 0;
  

•   FILE *f;
  

•   f = fopen("/proc/kallsyms", "r");
  

•   if (!f)
  

•           return -ENOENT;
  

•   while (fscanf(f, "%llx %c %499s%*[^\n]\n", &value, &type, name) > 0) {
  

•           if (strcmp(name, sym) == 0) {
  

•                   *addr = value;
  

•                   goto out;
  

•           }
  

•   }
  

•   err = -EINVAL;
  

These error codes seem backward to me. If you fail to open /proc/kallsyms, that's an unexpected and invalid situation, so EINVAL makes a bit more sense there. But -ENOENT is clearly for cases where you didn't find what you were looking for, which is exactly this case.

I thought about it. I used -ENOENT for fopen failure because I found -ENOENT is for the case when a file/directory is not found, which is more reasonable in describing fopen error. But your proposal also makes sense and that is what I originally had. It doesn't sound like a big deal, I can switch the order them in v3.

For me, ENOENT is about the logical entity the function is working with. For fopen() that would be file, so if it's not found -- ENOENT. But here, for kallsyms_find it's a ksym. If /proc/kallsyms isn't there or can't be open -- that's unexpected (EINVAL). But if /proc/kallsyms was open but didn't contain the entity we are looking for (requested ksym) -- that's ENOENT.

...

...

+out:

•   fclose(f);
  

•   return err;
  

+}

void read_trace_pipe(void) { int trace_fd; diff --git a/tools/testing/selftests/bpf/trace_helpers.h b/tools/testing/selftests/bpf/trace_helpers.h index 25ef597dd03f..f62fdef9e589 100644 --- a/tools/testing/selftests/bpf/trace_helpers.h +++ b/tools/testing/selftests/bpf/trace_helpers.h @@ -12,6 +12,10 @@ struct ksym { int load_kallsyms(void); struct ksym *ksym_search(long key); long ksym_get_addr(const char *name);

+/* open kallsyms and find addresses on the fly, faster than load + search. */ +int kallsyms_find(const char *sym, unsigned long long *addr);

void read_trace_pipe(void);

#endif

2.28.0.526.ge36021eeef-goog

On Thu, Sep 3, 2020 at 3:35 PM Hao Luo haoluo@google.com wrote:

Add bpf_per_cpu_ptr() to help bpf programs access percpu vars. bpf_per_cpu_ptr() has the same semantic as per_cpu_ptr() in the kernel except that it may return NULL. This happens when the cpu parameter is out of range. So the caller must check the returned value.

Acked-by: Andrii Nakryiko andriin@fb.com Signed-off-by: Hao Luo haoluo@google.com

---

include/linux/bpf.h | 3 ++ include/linux/btf.h | 11 ++++++ include/uapi/linux/bpf.h | 17 +++++++++ kernel/bpf/btf.c | 10 ------ kernel/bpf/verifier.c | 66 +++++++++++++++++++++++++++++++--- kernel/trace/bpf_trace.c | 18 ++++++++++ tools/include/uapi/linux/bpf.h | 17 +++++++++ 7 files changed, 128 insertions(+), 14 deletions(-)

diff --git a/include/linux/bpf.h b/include/linux/bpf.h index c6d9f2c444f4..6b2034f7665e 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -292,6 +292,7 @@ enum bpf_arg_type { ARG_PTR_TO_ALLOC_MEM, /* pointer to dynamically allocated memory */ ARG_PTR_TO_ALLOC_MEM_OR_NULL, /* pointer to dynamically allocated memory or NULL */ ARG_CONST_ALLOC_SIZE_OR_ZERO, /* number of allocated bytes requested */

•   ARG_PTR_TO_PERCPU_BTF_ID,       /* pointer to in-kernel percpu type */
  

};

/* type of values returned from helper functions */ @@ -305,6 +306,7 @@ enum bpf_return_type { RET_PTR_TO_SOCK_COMMON_OR_NULL, /* returns a pointer to a sock_common or NULL */ RET_PTR_TO_ALLOC_MEM_OR_NULL, /* returns a pointer to dynamically allocated memory or NULL */ RET_PTR_TO_BTF_ID_OR_NULL, /* returns a pointer to a btf_id or NULL */

•   RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL, /* returns a pointer to a valid memory or a btf_id or NULL */
  

};

/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs @@ -385,6 +387,7 @@ enum bpf_reg_type { PTR_TO_RDONLY_BUF_OR_NULL, /* reg points to a readonly buffer or NULL */ PTR_TO_RDWR_BUF, /* reg points to a read/write buffer */ PTR_TO_RDWR_BUF_OR_NULL, /* reg points to a read/write buffer or NULL */

•   PTR_TO_PERCPU_BTF_ID,    /* reg points to percpu kernel type */
  

};

/* The information passed from prog-specific *_is_valid_access diff --git a/include/linux/btf.h b/include/linux/btf.h index 592373d359b9..07b7de1c05b0 100644 --- a/include/linux/btf.h +++ b/include/linux/btf.h @@ -71,6 +71,11 @@ btf_resolve_size(const struct btf *btf, const struct btf_type *type, i < btf_type_vlen(struct_type); \ i++, member++)

+#define for_each_vsi(i, struct_type, member) \

datasec_type?

•   for (i = 0, member = btf_type_var_secinfo(struct_type); \
  

•        i < btf_type_vlen(struct_type);                    \
  

•        i++, member++)
  

static inline bool btf_type_is_ptr(const struct btf_type *t) { return BTF_INFO_KIND(t->info) == BTF_KIND_PTR; @@ -155,6 +160,12 @@ static inline const struct btf_member *btf_type_member(const struct btf_type *t) return (const struct btf_member *)(t + 1); }

+static inline const struct btf_var_secinfo *btf_type_var_secinfo(

•           const struct btf_type *t)
  

+{

•   return (const struct btf_var_secinfo *)(t + 1);
  

+}

#ifdef CONFIG_BPF_SYSCALL const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id); const char *btf_name_by_offset(const struct btf *btf, u32 offset); diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index ab00ad9b32e5..d0ec94d5bdbf 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -3596,6 +3596,22 @@ union bpf_attr {

•         the data in *dst*. This is a wrapper of copy_from_user().
  

• Return
  

•         0 on success, or a negative error in case of failure.
  

• • void *bpf_per_cpu_ptr(const void *percpu_ptr, u32 cpu)

• • Description
    

• •         Take a pointer to a percpu ksym, *percpu_ptr*, and return a
    

• •         pointer to the percpu kernel variable on *cpu*. A ksym is an
    

• •         extern variable decorated with '__ksym'. For ksym, there is a
    

• •         global var (either static or global) defined of the same name
    

• •         in the kernel. The ksym is percpu if the global var is percpu.
    

• •         The returned pointer points to the global percpu var on *cpu*.
    

• •         bpf_per_cpu_ptr() has the same semantic as per_cpu_ptr() in the
    

• •         kernel, except that bpf_per_cpu_ptr() may return NULL. This
    

• •         happens if *cpu* is larger than nr_cpu_ids. The caller of
    

• •         bpf_per_cpu_ptr() must check the returned value.
    

• • Return
    

• •         A generic pointer pointing to the kernel percpu variable on *cpu*.
    

Or NULL, if *cpu* is invalid.

*/ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3747,6 +3763,7 @@ union bpf_attr { FN(inode_storage_delete), \ FN(d_path), \ FN(copy_from_user), \

•   FN(bpf_per_cpu_ptr),            \
    /* */
  
  

[...]

@@ -4003,6 +4008,15 @@ static int check_func_arg(struct bpf_verifier_env *env, u32 arg, if (type != expected_type) goto err_type; }

•   } else if (arg_type == ARG_PTR_TO_PERCPU_BTF_ID) {
  

•           expected_type = PTR_TO_PERCPU_BTF_ID;
  

•           if (type != expected_type)
  

•                   goto err_type;
  

•           if (!reg->btf_id) {
  

•                   verbose(env, "Helper has invalid btf_id in R%d\n", regno);
  

•                   return -EACCES;
  

•           }
  

•           meta->ret_btf_id = reg->btf_id;
    } else if (arg_type == ARG_PTR_TO_BTF_ID) {
            bool ids_match = false;
  
  

@@ -5002,6 +5016,30 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn regs[BPF_REG_0].type = PTR_TO_MEM_OR_NULL; regs[BPF_REG_0].id = ++env->id_gen; regs[BPF_REG_0].mem_size = meta.mem_size;

•   } else if (fn->ret_type == RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL) {
  

Given this is internal implementation detail, this return type is fine, but I'm wondering if it would be better to just make PTR_TO_BTF_ID to allow not just structs? E.g., if we have an int, just allow reading those 4 bytes.

Not sure what the implications are in terms of implementation, but conceptually that shouldn't be a problem, given we do have BTF type ID describing size and all.

•           const struct btf_type *t;
  

•           mark_reg_known_zero(env, regs, BPF_REG_0);
  

•           t = btf_type_skip_modifiers(btf_vmlinux, meta.ret_btf_id, NULL);
  

•           if (!btf_type_is_struct(t)) {
  

•                   u32 tsize;
  

•                   const struct btf_type *ret;
  

•                   const char *tname;
  

•                   /* resolve the type size of ksym. */
  

•                   ret = btf_resolve_size(btf_vmlinux, t, &tsize);
  

•                   if (IS_ERR(ret)) {
  

•                           tname = btf_name_by_offset(btf_vmlinux, t->name_off);
  

•                           verbose(env, "unable to resolve the size of type '%s': %ld\n",
  

•                                   tname, PTR_ERR(ret));
  

•                           return -EINVAL;
  

•                   }
  

•                   regs[BPF_REG_0].type = PTR_TO_MEM_OR_NULL;
  

•                   regs[BPF_REG_0].mem_size = tsize;
  

•           } else {
  

•                   regs[BPF_REG_0].type = PTR_TO_BTF_ID_OR_NULL;
  

•                   regs[BPF_REG_0].btf_id = meta.ret_btf_id;
  

•           }
    } else if (fn->ret_type == RET_PTR_TO_BTF_ID_OR_NULL) {
            int ret_btf_id;
  
  

[...]

diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c index b2a5380eb187..d474c1530f87 100644 --- a/kernel/trace/bpf_trace.c +++ b/kernel/trace/bpf_trace.c @@ -1144,6 +1144,22 @@ static const struct bpf_func_proto bpf_d_path_proto = { .allowed = bpf_d_path_allowed, };

+BPF_CALL_2(bpf_per_cpu_ptr, const void *, ptr, u32, cpu) +{

•   if (cpu >= nr_cpu_ids)
  

•           return 0;
  

•   return (u64)per_cpu_ptr(ptr, cpu);
  

not sure, but on 32-bit arches this might cause compilation warning, case to (unsigned long) instead?

+}

+static const struct bpf_func_proto bpf_per_cpu_ptr_proto = {

•   .func           = bpf_per_cpu_ptr,
  

•   .gpl_only       = false,
  

•   .ret_type       = RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL,
  

•   .arg1_type      = ARG_PTR_TO_PERCPU_BTF_ID,
  

•   .arg2_type      = ARG_ANYTHING,
  

+};

[...]

On Sun, Sep 13, 2020 at 10:01 PM Hao Luo haoluo@google.com wrote:

Thanks for review, Andrii.

One question, should I add bpf_{per, this}_cpu_ptr() to the bpf_base_func_proto() in kernel/bpf/helpers.c?

Yes, probably, but given it allows poking at kernel memory, it probably needs to be guarded by perfmon_capable() check, similar to bpf_get_current_task_proto.

On Fri, Sep 4, 2020 at 1:04 PM Andrii Nakryiko andrii.nakryiko@gmail.com wrote:

...

On Thu, Sep 3, 2020 at 3:35 PM Hao Luo haoluo@google.com wrote:

...

Add bpf_per_cpu_ptr() to help bpf programs access percpu vars. bpf_per_cpu_ptr() has the same semantic as per_cpu_ptr() in the kernel except that it may return NULL. This happens when the cpu parameter is out of range. So the caller must check the returned value.

Acked-by: Andrii Nakryiko andriin@fb.com Signed-off-by: Hao Luo haoluo@google.com

---

include/linux/bpf.h | 3 ++ include/linux/btf.h | 11 ++++++ include/uapi/linux/bpf.h | 17 +++++++++ kernel/bpf/btf.c | 10 ------ kernel/bpf/verifier.c | 66 +++++++++++++++++++++++++++++++--- kernel/trace/bpf_trace.c | 18 ++++++++++ tools/include/uapi/linux/bpf.h | 17 +++++++++ 7 files changed, 128 insertions(+), 14 deletions(-)

[...]

...

...

@@ -5002,6 +5016,30 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn regs[BPF_REG_0].type = PTR_TO_MEM_OR_NULL; regs[BPF_REG_0].id = ++env->id_gen; regs[BPF_REG_0].mem_size = meta.mem_size;

•   } else if (fn->ret_type == RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL) {
  

Given this is internal implementation detail, this return type is fine, but I'm wondering if it would be better to just make PTR_TO_BTF_ID to allow not just structs? E.g., if we have an int, just allow reading those 4 bytes.

Not sure what the implications are in terms of implementation, but conceptually that shouldn't be a problem, given we do have BTF type ID describing size and all.

Yeah. Totally agree. I looked at it initially. My take is PTR_TO_BTF_ID is meant for struct types. It required some code refactoring to break this assumption. I can add it to my TODO list and investigate it if this makes more sense.

PTR_TO_BTF_ID was *implemented* for struct, but at least naming-wise nothing suggests it has to be restricted to structs. But yeah, this should be a separate change, don't block your patches on that.

...

...

•           const struct btf_type *t;
  

[...]

On Thu, Sep 3, 2020 at 3:35 PM Hao Luo haoluo@google.com wrote:

Add bpf_this_cpu_ptr() to help access percpu var on this cpu. This helper always returns a valid pointer, therefore no need to check returned value for NULL. Also note that all programs run with preemption disabled, which means that the returned pointer is stable during all the execution of the program.

Signed-off-by: Hao Luo haoluo@google.com

looks good, few small things, but otherwise:

Acked-by: Andrii Nakryiko andriin@fb.com

include/linux/bpf.h | 1 + include/uapi/linux/bpf.h | 14 ++++++++++++++ kernel/bpf/verifier.c | 10 +++++++--- kernel/trace/bpf_trace.c | 14 ++++++++++++++ tools/include/uapi/linux/bpf.h | 14 ++++++++++++++ 5 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 6b2034f7665e..506fdd5d0463 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -307,6 +307,7 @@ enum bpf_return_type { RET_PTR_TO_ALLOC_MEM_OR_NULL, /* returns a pointer to dynamically allocated memory or NULL */ RET_PTR_TO_BTF_ID_OR_NULL, /* returns a pointer to a btf_id or NULL */ RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL, /* returns a pointer to a valid memory or a btf_id or NULL */

•   RET_PTR_TO_MEM_OR_BTF_ID,       /* returns a pointer to a valid memory or a btf_id */
  

};

/* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index d0ec94d5bdbf..e7ca91c697ed 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -3612,6 +3612,19 @@ union bpf_attr {

•         bpf_per_cpu_ptr() must check the returned value.
  

• Return
  

•         A generic pointer pointing to the kernel percpu variable on *cpu*.
  

• • void *bpf_this_cpu_ptr(const void *percpu_ptr)

• • Description
    

• •         Take a pointer to a percpu ksym, *percpu_ptr*, and return a
    

• •         pointer to the percpu kernel variable on this cpu. See the
    

• •         description of 'ksym' in **bpf_per_cpu_ptr**\ ().
    

• •         bpf_this_cpu_ptr() has the same semantic as this_cpu_ptr() in
    

• •         the kernel. Different from **bpf_per_cpu_ptr**\ (), it would
    

• •         never return NULL.
    

• • Return
    

• •         A generic pointer pointing to the kernel percpu variable on
    

what's "a generic pointer"? is it as opposed to sk_buff pointer or something?

• •         this cpu.
    

  */

#define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ @@ -3764,6 +3777,7 @@ union bpf_attr { FN(d_path), \ FN(copy_from_user), \ FN(bpf_per_cpu_ptr), \

•   FN(bpf_this_cpu_ptr),           \
    /* */
  
  

/* integer value in 'imm' field of BPF_CALL instruction selects which helper diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index a702600ff581..e070d2abc405 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -5016,8 +5016,10 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn regs[BPF_REG_0].type = PTR_TO_MEM_OR_NULL; regs[BPF_REG_0].id = ++env->id_gen; regs[BPF_REG_0].mem_size = meta.mem_size;

•   } else if (fn->ret_type == RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL) {
  

•   } else if (fn->ret_type == RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL ||
  

•              fn->ret_type == RET_PTR_TO_MEM_OR_BTF_ID) {
            const struct btf_type *t;
  

•           bool not_null = fn->ret_type == RET_PTR_TO_MEM_OR_BTF_ID;
  

nit: this is fine, but I'd inline it below

            mark_reg_known_zero(env, regs, BPF_REG_0);
            t = btf_type_skip_modifiers(btf_vmlinux, meta.ret_btf_id, NULL);

@@ -5034,10 +5036,12 @@ static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn tname, PTR_ERR(ret)); return -EINVAL; }

•                   regs[BPF_REG_0].type = PTR_TO_MEM_OR_NULL;
  

•                   regs[BPF_REG_0].type = not_null ?
  

•                           PTR_TO_MEM : PTR_TO_MEM_OR_NULL;
                    regs[BPF_REG_0].mem_size = tsize;
            } else {
  

•                   regs[BPF_REG_0].type = PTR_TO_BTF_ID_OR_NULL;
  

•                   regs[BPF_REG_0].type = not_null ?
  

•                           PTR_TO_BTF_ID : PTR_TO_BTF_ID_OR_NULL;
                    regs[BPF_REG_0].btf_id = meta.ret_btf_id;
            }
    } else if (fn->ret_type == RET_PTR_TO_BTF_ID_OR_NULL) {
  

diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c index d474c1530f87..466acf82a9c7 100644 --- a/kernel/trace/bpf_trace.c +++ b/kernel/trace/bpf_trace.c @@ -1160,6 +1160,18 @@ static const struct bpf_func_proto bpf_per_cpu_ptr_proto = { .arg2_type = ARG_ANYTHING, };

+BPF_CALL_1(bpf_this_cpu_ptr, const void *, percpu_ptr) +{

•   return (u64)this_cpu_ptr(percpu_ptr);
  

see previous comment, this might trigger unnecessary compilation warnings on 32-bit arches

+}

+static const struct bpf_func_proto bpf_this_cpu_ptr_proto = {

•   .func           = bpf_this_cpu_ptr,
  

•   .gpl_only       = false,
  

•   .ret_type       = RET_PTR_TO_MEM_OR_BTF_ID,
  

•   .arg1_type      = ARG_PTR_TO_PERCPU_BTF_ID,
  

+};

[...]

Thanks for taking a look!

On Fri, Sep 4, 2020 at 1:15 PM Andrii Nakryiko andrii.nakryiko@gmail.com wrote:

On Thu, Sep 3, 2020 at 3:35 PM Hao Luo haoluo@google.com wrote:

...

Test bpf_per_cpu_ptr() and bpf_this_cpu_ptr(). Test two paths in the kernel. If the base pointer points to a struct, the returned reg is of type PTR_TO_BTF_ID. Direct pointer dereference can be applied on the returned variable. If the base pointer isn't a struct, the returned reg is of type PTR_TO_MEM, which also supports direct pointer dereference.

Acked-by: Andrii Nakryiko andriin@fb.com Signed-off-by: Hao Luo haoluo@google.com

---

.../selftests/bpf/prog_tests/ksyms_btf.c | 10 +++++++ .../selftests/bpf/progs/test_ksyms_btf.c | 26 +++++++++++++++++++ 2 files changed, 36 insertions(+)

diff --git a/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c b/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c index 7b6846342449..22cc642dbc0e 100644 --- a/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c +++ b/tools/testing/selftests/bpf/prog_tests/ksyms_btf.c @@ -58,6 +58,16 @@ void test_ksyms_btf(void) CHECK(data->out__bpf_prog_active != bpf_prog_active_addr, "bpf_prog_active", "got %llu, exp %llu\n", data->out__bpf_prog_active, bpf_prog_active_addr);

•   CHECK(data->out__rq_cpu == -1, "rq_cpu",
  

•         "got %u, exp != -1\n", data->out__rq_cpu);
  

•   CHECK(data->out__percpu_bpf_prog_active == -1, "percpu_bpf_prog_active",
  

•         "got %d, exp != -1\n", data->out__percpu_bpf_prog_active);
  

•   CHECK(data->out__this_rq_cpu == -1, "this_rq_cpu",
  

•         "got %u, exp != -1\n", data->out__this_rq_cpu);
  

•   CHECK(data->out__this_bpf_prog_active == -1, "this_bpf_prog_active",
  

•         "got %d, exp != -1\n", data->out__this_bpf_prog_active);
  

see below for few suggestions to make these test more specific

out__this_bpf_prog_active it should always be > 0, no?

I could be wrong, but I remember raw_trace_point is not tracked by bpf_prog_active. So I used bpf_prog_active >= 0 to be safe.

...

cleanup: test_ksyms_btf__destroy(skel); } diff --git a/tools/testing/selftests/bpf/progs/test_ksyms_btf.c b/tools/testing/selftests/bpf/progs/test_ksyms_btf.c index e04e31117f84..02d564349892 100644 --- a/tools/testing/selftests/bpf/progs/test_ksyms_btf.c +++ b/tools/testing/selftests/bpf/progs/test_ksyms_btf.c @@ -8,15 +8,41 @@ __u64 out__runqueues = -1; __u64 out__bpf_prog_active = -1;

+__u32 out__rq_cpu = -1; /* percpu struct fields */ +int out__percpu_bpf_prog_active = -1; /* percpu int */

+__u32 out__this_rq_cpu = -1; +int out__this_bpf_prog_active = -1;

extern const struct rq runqueues __ksym; /* struct type global var. */ extern const int bpf_prog_active __ksym; /* int type global var. */

SEC("raw_tp/sys_enter") int handler(const void *ctx) {

•   struct rq *rq;
  

•   int *active;
  

•   __u32 cpu;
  

•   out__runqueues = (__u64)&runqueues;
    out__bpf_prog_active = (__u64)&bpf_prog_active;
  
  

•   cpu = bpf_get_smp_processor_id();
  

•   /* test bpf_per_cpu_ptr() */
  

•   rq = (struct rq *)bpf_per_cpu_ptr(&runqueues, cpu);
  

•   if (rq)
  

•           out__rq_cpu = rq->cpu;
  

•   active = (int *)bpf_per_cpu_ptr(&bpf_prog_active, cpu);
  

•   if (active)
  

•           out__percpu_bpf_prog_active = *active;
  

this is equivalent to using bpf_this_cpu_ptr(), so:

1. you can compare value with out__this_xxx in user-space

2. it's interesting to also test that you can read value from some

other CPU. Can you add another variable and get value from CPU #0 always? E.g., for out__cpu_0_rq_cpu it should always be zero, right?

Ack. That makes sense. You are right, out__cpu_0_rq_cpu is always zero.

...

•   /* test bpf_this_cpu_ptr */
  

•   rq = (struct rq *)bpf_this_cpu_ptr(&runqueues);
  

•   out__this_rq_cpu = rq->cpu;
  

•   active = (int *)bpf_this_cpu_ptr(&bpf_prog_active);
  

•   out__this_bpf_prog_active = *active;
  

•   return 0;
  

}

-- 2.28.0.526.ge36021eeef-goog