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

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <test_progs.h>
   3 #include <network_helpers.h>
   4
   5 static void test_global_data_number(struct bpf_object *obj, __u32 duration)
   6 {
   7         int i, err, map_fd;
   8         __u64 num;
   9
  10         map_fd = bpf_find_map(__func__, obj, "result_number");
  11         if (CHECK_FAIL(map_fd < 0))
  12                 return;
  13
  14         struct {
  15                 char *name;
  16                 uint32_t key;
  17                 __u64 num;
  18         } tests[] = {
  19                 { "relocate .bss reference",     0, 0 },
  20                 { "relocate .data reference",    1, 42 },
  21                 { "relocate .rodata reference",  2, 24 },
  22                 { "relocate .bss reference",     3, 0 },
  23                 { "relocate .data reference",    4, 0xffeeff },
  24                 { "relocate .rodata reference",  5, 0xabab },
  25                 { "relocate .bss reference",     6, 1234 },
  26                 { "relocate .bss reference",     7, 0 },
  27                 { "relocate .rodata reference",  8, 0xab },
  28                 { "relocate .rodata reference",  9, 0x1111111111111111 },
  29                 { "relocate .rodata reference", 10, ~0 },
  30         };
  31
  32         for (i = 0; i < ARRAY_SIZE(tests); i++) {
  33                 err = bpf_map_lookup_elem(map_fd, &tests[i].key, &num);
  34                 CHECK(err || num != tests[i].num, tests[i].name,
  35                       "err %d result %llx expected %llx\n",
  36                       err, num, tests[i].num);
  37         }
  38 }
  39
  40 static void test_global_data_string(struct bpf_object *obj, __u32 duration)
  41 {
  42         int i, err, map_fd;
  43         char str[32];
  44
  45         map_fd = bpf_find_map(__func__, obj, "result_string");
  46         if (CHECK_FAIL(map_fd < 0))
  47                 return;
  48
  49         struct {
  50                 char *name;
  51                 uint32_t key;
  52                 char str[32];
  53         } tests[] = {
  54                 { "relocate .rodata reference", 0, "abcdefghijklmnopqrstuvwxyz" },
  55                 { "relocate .data reference",   1, "abcdefghijklmnopqrstuvwxyz" },
  56                 { "relocate .bss reference",    2, "" },
  57                 { "relocate .data reference",   3, "abcdexghijklmnopqrstuvwxyz" },
  58                 { "relocate .bss reference",    4, "\0\0hello" },
  59         };
  60
  61         for (i = 0; i < ARRAY_SIZE(tests); i++) {
  62                 err = bpf_map_lookup_elem(map_fd, &tests[i].key, str);
  63                 CHECK(err || memcmp(str, tests[i].str, sizeof(str)),
  64                       tests[i].name, "err %d result \'%s\' expected \'%s\'\n",
  65                       err, str, tests[i].str);
  66         }
  67 }
  68
  69 struct foo {
  70         __u8  a;
  71         __u32 b;
  72         __u64 c;
  73 };
  74
  75 static void test_global_data_struct(struct bpf_object *obj, __u32 duration)
  76 {
  77         int i, err, map_fd;
  78         struct foo val;
  79
  80         map_fd = bpf_find_map(__func__, obj, "result_struct");
  81         if (CHECK_FAIL(map_fd < 0))
  82                 return;
  83
  84         struct {
  85                 char *name;
  86                 uint32_t key;
  87                 struct foo val;
  88         } tests[] = {
  89                 { "relocate .rodata reference", 0, { 42, 0xfefeefef, 0x1111111111111111ULL, } },
  90                 { "relocate .bss reference",    1, { } },
  91                 { "relocate .rodata reference", 2, { } },
  92                 { "relocate .data reference",   3, { 41, 0xeeeeefef, 0x2111111111111111ULL, } },
  93         };
  94
  95         for (i = 0; i < ARRAY_SIZE(tests); i++) {
  96                 err = bpf_map_lookup_elem(map_fd, &tests[i].key, &val);
  97                 CHECK(err || memcmp(&val, &tests[i].val, sizeof(val)),
  98                       tests[i].name, "err %d result { %u, %u, %llu } expected { %u, %u, %llu }\n",
  99                       err, val.a, val.b, val.c, tests[i].val.a, tests[i].val.b, tests[i].val.c);
 100         }
 101 }
 102
 103 static void test_global_data_rdonly(struct bpf_object *obj, __u32 duration)
 104 {
 105         int err = -ENOMEM, map_fd, zero = 0;
 106         struct bpf_map *map, *map2;
 107         __u8 *buff;
 108
 109         map = bpf_object__find_map_by_name(obj, "test_glo.rodata");
 110         if (!ASSERT_OK_PTR(map, "map"))
 111                 return;
 112         if (!ASSERT_TRUE(bpf_map__is_internal(map), "is_internal"))
 113                 return;
 114
 115         /* ensure we can lookup internal maps by their ELF names */
 116         map2 = bpf_object__find_map_by_name(obj, ".rodata");
 117         if (!ASSERT_EQ(map, map2, "same_maps"))
 118                 return;
 119
 120         map_fd = bpf_map__fd(map);
 121         if (CHECK_FAIL(map_fd < 0))
 122                 return;
 123
 124         buff = malloc(bpf_map__value_size(map));
 125         if (buff)
 126                 err = bpf_map_update_elem(map_fd, &zero, buff, 0);
 127         free(buff);
 128         CHECK(!err || errno != EPERM, "test .rodata read-only map",
 129               "err %d errno %d\n", err, errno);
 130 }
 131
 132 void test_global_data(void)
 133 {
 134         const char *file = "./test_global_data.bpf.o";
 135         struct bpf_object *obj;
 136         int err, prog_fd;
 137         LIBBPF_OPTS(bpf_test_run_opts, topts,
 138                 .data_in = &pkt_v4,
 139                 .data_size_in = sizeof(pkt_v4),
 140                 .repeat = 1,
 141         );
 142
 143         err = bpf_prog_test_load(file, BPF_PROG_TYPE_SCHED_CLS, &obj, &prog_fd);
 144         if (!ASSERT_OK(err, "load program"))
 145                 return;
 146
 147         err = bpf_prog_test_run_opts(prog_fd, &topts);
 148         ASSERT_OK(err, "pass global data run err");
 149         ASSERT_OK(topts.retval, "pass global data run retval");
 150
 151         test_global_data_number(obj, topts.duration);
 152         test_global_data_string(obj, topts.duration);
 153         test_global_data_struct(obj, topts.duration);
 154         test_global_data_rdonly(obj, topts.duration);
 155
 156         bpf_object__close(obj);
 157 }