1// SPDX-License-Identifier: GPL-2.0
  2#include <test_progs.h>
  3#include <network_helpers.h>
  4
  5static 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
 40static 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
 69struct foo {
 70	__u8  a;
 71	__u32 b;
 72	__u64 c;
 73};
 74
 75static 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
103static 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
132void 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}