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

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