1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (c) 2021 Facebook */
3#include <test_progs.h>
4#include <network_helpers.h>
5#include "for_each_hash_map_elem.skel.h"
6#include "for_each_array_map_elem.skel.h"
7#include "for_each_map_elem_write_key.skel.h"
8
9static unsigned int duration;
10
11static void test_hash_map(void)
12{
13	int i, err, max_entries;
14	struct for_each_hash_map_elem *skel;
15	__u64 *percpu_valbuf = NULL;
16	size_t percpu_val_sz;
17	__u32 key, num_cpus;
18	__u64 val;
19	LIBBPF_OPTS(bpf_test_run_opts, topts,
20		.data_in = &pkt_v4,
21		.data_size_in = sizeof(pkt_v4),
22		.repeat = 1,
23	);
24
25	skel = for_each_hash_map_elem__open_and_load();
26	if (!ASSERT_OK_PTR(skel, "for_each_hash_map_elem__open_and_load"))
27		return;
28
29	max_entries = bpf_map__max_entries(skel->maps.hashmap);
30	for (i = 0; i < max_entries; i++) {
31		key = i;
32		val = i + 1;
33		err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
34					   &val, sizeof(val), BPF_ANY);
35		if (!ASSERT_OK(err, "map_update"))
36			goto out;
37	}
38
39	num_cpus = bpf_num_possible_cpus();
40	percpu_val_sz = sizeof(__u64) * num_cpus;
41	percpu_valbuf = malloc(percpu_val_sz);
42	if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
43		goto out;
44
45	key = 1;
46	for (i = 0; i < num_cpus; i++)
47		percpu_valbuf[i] = i + 1;
48	err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
49				   percpu_valbuf, percpu_val_sz, BPF_ANY);
50	if (!ASSERT_OK(err, "percpu_map_update"))
51		goto out;
52
53	err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
54	duration = topts.duration;
55	if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
56		  err, errno, topts.retval))
57		goto out;
58
59	ASSERT_EQ(skel->bss->hashmap_output, 4, "hashmap_output");
60	ASSERT_EQ(skel->bss->hashmap_elems, max_entries, "hashmap_elems");
61
62	key = 1;
63	err = bpf_map__lookup_elem(skel->maps.hashmap, &key, sizeof(key), &val, sizeof(val), 0);
64	ASSERT_ERR(err, "hashmap_lookup");
65
66	ASSERT_EQ(skel->bss->percpu_called, 1, "percpu_called");
67	ASSERT_LT(skel->bss->cpu, num_cpus, "num_cpus");
68	ASSERT_EQ(skel->bss->percpu_map_elems, 1, "percpu_map_elems");
69	ASSERT_EQ(skel->bss->percpu_key, 1, "percpu_key");
70	ASSERT_EQ(skel->bss->percpu_val, skel->bss->cpu + 1, "percpu_val");
71	ASSERT_EQ(skel->bss->percpu_output, 100, "percpu_output");
72out:
73	free(percpu_valbuf);
74	for_each_hash_map_elem__destroy(skel);
75}
76
77static void test_array_map(void)
78{
79	__u32 key, num_cpus, max_entries;
80	int i, err;
81	struct for_each_array_map_elem *skel;
82	__u64 *percpu_valbuf = NULL;
83	size_t percpu_val_sz;
84	__u64 val, expected_total;
85	LIBBPF_OPTS(bpf_test_run_opts, topts,
86		.data_in = &pkt_v4,
87		.data_size_in = sizeof(pkt_v4),
88		.repeat = 1,
89	);
90
91	skel = for_each_array_map_elem__open_and_load();
92	if (!ASSERT_OK_PTR(skel, "for_each_array_map_elem__open_and_load"))
93		return;
94
95	expected_total = 0;
96	max_entries = bpf_map__max_entries(skel->maps.arraymap);
97	for (i = 0; i < max_entries; i++) {
98		key = i;
99		val = i + 1;
100		/* skip the last iteration for expected total */
101		if (i != max_entries - 1)
102			expected_total += val;
103		err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key),
104					   &val, sizeof(val), BPF_ANY);
105		if (!ASSERT_OK(err, "map_update"))
106			goto out;
107	}
108
109	num_cpus = bpf_num_possible_cpus();
110	percpu_val_sz = sizeof(__u64) * num_cpus;
111	percpu_valbuf = malloc(percpu_val_sz);
112	if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
113		goto out;
114
115	key = 0;
116	for (i = 0; i < num_cpus; i++)
117		percpu_valbuf[i] = i + 1;
118	err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
119				   percpu_valbuf, percpu_val_sz, BPF_ANY);
120	if (!ASSERT_OK(err, "percpu_map_update"))
121		goto out;
122
123	err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
124	duration = topts.duration;
125	if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
126		  err, errno, topts.retval))
127		goto out;
128
129	ASSERT_EQ(skel->bss->arraymap_output, expected_total, "array_output");
130	ASSERT_EQ(skel->bss->cpu + 1, skel->bss->percpu_val, "percpu_val");
131
132out:
133	free(percpu_valbuf);
134	for_each_array_map_elem__destroy(skel);
135}
136
137static void test_write_map_key(void)
138{
139	struct for_each_map_elem_write_key *skel;
140
141	skel = for_each_map_elem_write_key__open_and_load();
142	if (!ASSERT_ERR_PTR(skel, "for_each_map_elem_write_key__open_and_load"))
143		for_each_map_elem_write_key__destroy(skel);
144}
145
146void test_for_each(void)
147{
148	if (test__start_subtest("hash_map"))
149		test_hash_map();
150	if (test__start_subtest("array_map"))
151		test_array_map();
152	if (test__start_subtest("write_map_key"))
153		test_write_map_key();
154}
155