tools/testing/selftests/bpf/prog_tests/ksyms_btf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020 Google */
   3
   4 #include <test_progs.h>
   5 #include <bpf/libbpf.h>
   6 #include <bpf/btf.h>
   7 #include "test_ksyms_btf.skel.h"
   8 #include "test_ksyms_btf_null_check.skel.h"
   9 #include "test_ksyms_weak.skel.h"
  10 #include "test_ksyms_weak.lskel.h"
  11 #include "test_ksyms_btf_write_check.skel.h"
  12
  13 static int duration;
  14
  15 static void test_basic(void)
  16 {
  17         __u64 runqueues_addr, bpf_prog_active_addr;
  18         __u32 this_rq_cpu;
  19         int this_bpf_prog_active;
  20         struct test_ksyms_btf *skel = NULL;
  21         struct test_ksyms_btf__data *data;
  22         int err;
  23
  24         err = kallsyms_find("runqueues", &runqueues_addr);
  25         if (CHECK(err == -EINVAL, "kallsyms_fopen", "failed to open: %d\n", errno))
  26                 return;
  27         if (CHECK(err == -ENOENT, "ksym_find", "symbol 'runqueues' not found\n"))
  28                 return;
  29
  30         err = kallsyms_find("bpf_prog_active", &bpf_prog_active_addr);
  31         if (CHECK(err == -EINVAL, "kallsyms_fopen", "failed to open: %d\n", errno))
  32                 return;
  33         if (CHECK(err == -ENOENT, "ksym_find", "symbol 'bpf_prog_active' not found\n"))
  34                 return;
  35
  36         skel = test_ksyms_btf__open_and_load();
  37         if (CHECK(!skel, "skel_open", "failed to open and load skeleton\n"))
  38                 goto cleanup;
  39
  40         err = test_ksyms_btf__attach(skel);
  41         if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
  42                 goto cleanup;
  43
  44         /* trigger tracepoint */
  45         usleep(1);
  46
  47         data = skel->data;
  48         CHECK(data->out__runqueues_addr != runqueues_addr, "runqueues_addr",
  49               "got %llu, exp %llu\n",
  50               (unsigned long long)data->out__runqueues_addr,
  51               (unsigned long long)runqueues_addr);
  52         CHECK(data->out__bpf_prog_active_addr != bpf_prog_active_addr, "bpf_prog_active_addr",
  53               "got %llu, exp %llu\n",
  54               (unsigned long long)data->out__bpf_prog_active_addr,
  55               (unsigned long long)bpf_prog_active_addr);
  56
  57         CHECK(data->out__rq_cpu == -1, "rq_cpu",
  58               "got %u, exp != -1\n", data->out__rq_cpu);
  59         CHECK(data->out__bpf_prog_active < 0, "bpf_prog_active",
  60               "got %d, exp >= 0\n", data->out__bpf_prog_active);
  61         CHECK(data->out__cpu_0_rq_cpu != 0, "cpu_rq(0)->cpu",
  62               "got %u, exp 0\n", data->out__cpu_0_rq_cpu);
  63
  64         this_rq_cpu = data->out__this_rq_cpu;
  65         CHECK(this_rq_cpu != data->out__rq_cpu, "this_rq_cpu",
  66               "got %u, exp %u\n", this_rq_cpu, data->out__rq_cpu);
  67
  68         this_bpf_prog_active = data->out__this_bpf_prog_active;
  69         CHECK(this_bpf_prog_active != data->out__bpf_prog_active, "this_bpf_prog_active",
  70               "got %d, exp %d\n", this_bpf_prog_active,
  71               data->out__bpf_prog_active);
  72
  73 cleanup:
  74         test_ksyms_btf__destroy(skel);
  75 }
  76
  77 static void test_null_check(void)
  78 {
  79         struct test_ksyms_btf_null_check *skel;
  80
  81         skel = test_ksyms_btf_null_check__open_and_load();
  82         CHECK(skel, "skel_open", "unexpected load of a prog missing null check\n");
  83
  84         test_ksyms_btf_null_check__destroy(skel);
  85 }
  86
  87 static void test_weak_syms(void)
  88 {
  89         struct test_ksyms_weak *skel;
  90         struct test_ksyms_weak__data *data;
  91         int err;
  92
  93         skel = test_ksyms_weak__open_and_load();
  94         if (!ASSERT_OK_PTR(skel, "test_ksyms_weak__open_and_load"))
  95                 return;
  96
  97         err = test_ksyms_weak__attach(skel);
  98         if (!ASSERT_OK(err, "test_ksyms_weak__attach"))
  99                 goto cleanup;
 100
 101         /* trigger tracepoint */
 102         usleep(1);
 103
 104         data = skel->data;
 105         ASSERT_EQ(data->out__existing_typed, 0, "existing typed ksym");
 106         ASSERT_NEQ(data->out__existing_typeless, -1, "existing typeless ksym");
 107         ASSERT_EQ(data->out__non_existent_typeless, 0, "nonexistent typeless ksym");
 108         ASSERT_EQ(data->out__non_existent_typed, 0, "nonexistent typed ksym");
 109
 110 cleanup:
 111         test_ksyms_weak__destroy(skel);
 112 }
 113
 114 static void test_weak_syms_lskel(void)
 115 {
 116         struct test_ksyms_weak_lskel *skel;
 117         struct test_ksyms_weak_lskel__data *data;
 118         int err;
 119
 120         skel = test_ksyms_weak_lskel__open_and_load();
 121         if (!ASSERT_OK_PTR(skel, "test_ksyms_weak_lskel__open_and_load"))
 122                 return;
 123
 124         err = test_ksyms_weak_lskel__attach(skel);
 125         if (!ASSERT_OK(err, "test_ksyms_weak_lskel__attach"))
 126                 goto cleanup;
 127
 128         /* trigger tracepoint */
 129         usleep(1);
 130
 131         data = skel->data;
 132         ASSERT_EQ(data->out__existing_typed, 0, "existing typed ksym");
 133         ASSERT_NEQ(data->out__existing_typeless, -1, "existing typeless ksym");
 134         ASSERT_EQ(data->out__non_existent_typeless, 0, "nonexistent typeless ksym");
 135         ASSERT_EQ(data->out__non_existent_typed, 0, "nonexistent typed ksym");
 136
 137 cleanup:
 138         test_ksyms_weak_lskel__destroy(skel);
 139 }
 140
 141 static void test_write_check(bool test_handler1)
 142 {
 143         struct test_ksyms_btf_write_check *skel;
 144
 145         skel = test_ksyms_btf_write_check__open();
 146         if (!ASSERT_OK_PTR(skel, "test_ksyms_btf_write_check__open"))
 147                 return;
 148         bpf_program__set_autoload(test_handler1 ? skel->progs.handler2 : skel->progs.handler1, false);
 149         ASSERT_ERR(test_ksyms_btf_write_check__load(skel),
 150                    "unexpected load of a prog writing to ksym memory\n");
 151
 152         test_ksyms_btf_write_check__destroy(skel);
 153 }
 154
 155 void test_ksyms_btf(void)
 156 {
 157         int percpu_datasec;
 158         struct btf *btf;
 159
 160         btf = libbpf_find_kernel_btf();
 161         if (!ASSERT_OK_PTR(btf, "btf_exists"))
 162                 return;
 163
 164         percpu_datasec = btf__find_by_name_kind(btf, ".data..percpu",
 165                                                 BTF_KIND_DATASEC);
 166         btf__free(btf);
 167         if (percpu_datasec < 0) {
 168                 printf("%s:SKIP:no PERCPU DATASEC in kernel btf\n",
 169                        __func__);
 170                 test__skip();
 171                 return;
 172         }
 173
 174         if (test__start_subtest("basic"))
 175                 test_basic();
 176
 177         if (test__start_subtest("null_check"))
 178                 test_null_check();
 179
 180         if (test__start_subtest("weak_ksyms"))
 181                 test_weak_syms();
 182
 183         if (test__start_subtest("weak_ksyms_lskel"))
 184                 test_weak_syms_lskel();
 185
 186         if (test__start_subtest("write_check1"))
 187                 test_write_check(true);
 188
 189         if (test__start_subtest("write_check2"))
 190                 test_write_check(false);
 191 }