Loading...
1// SPDX-License-Identifier: GPL-2.0
2#include <test_progs.h>
3#include <network_helpers.h>
4
5#include "map_kptr.skel.h"
6#include "map_kptr_fail.skel.h"
7#include "rcu_tasks_trace_gp.skel.h"
8
9static void test_map_kptr_success(bool test_run)
10{
11 LIBBPF_OPTS(bpf_test_run_opts, lopts);
12 LIBBPF_OPTS(bpf_test_run_opts, opts,
13 .data_in = &pkt_v4,
14 .data_size_in = sizeof(pkt_v4),
15 .repeat = 1,
16 );
17 int key = 0, ret, cpu;
18 struct map_kptr *skel;
19 char buf[16], *pbuf;
20
21 skel = map_kptr__open_and_load();
22 if (!ASSERT_OK_PTR(skel, "map_kptr__open_and_load"))
23 return;
24
25 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref1), &opts);
26 ASSERT_OK(ret, "test_map_kptr_ref1 refcount");
27 ASSERT_OK(opts.retval, "test_map_kptr_ref1 retval");
28 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref2), &opts);
29 ASSERT_OK(ret, "test_map_kptr_ref2 refcount");
30 ASSERT_OK(opts.retval, "test_map_kptr_ref2 retval");
31
32 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_ls_map_kptr_ref1), &lopts);
33 ASSERT_OK(ret, "test_ls_map_kptr_ref1 refcount");
34 ASSERT_OK(lopts.retval, "test_ls_map_kptr_ref1 retval");
35
36 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_ls_map_kptr_ref2), &lopts);
37 ASSERT_OK(ret, "test_ls_map_kptr_ref2 refcount");
38 ASSERT_OK(lopts.retval, "test_ls_map_kptr_ref2 retval");
39
40 if (test_run)
41 goto exit;
42
43 cpu = libbpf_num_possible_cpus();
44 if (!ASSERT_GT(cpu, 0, "libbpf_num_possible_cpus"))
45 goto exit;
46
47 pbuf = calloc(cpu, sizeof(buf));
48 if (!ASSERT_OK_PTR(pbuf, "calloc(pbuf)"))
49 goto exit;
50
51 ret = bpf_map__update_elem(skel->maps.array_map,
52 &key, sizeof(key), buf, sizeof(buf), 0);
53 ASSERT_OK(ret, "array_map update");
54 skel->data->ref--;
55 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
56 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
57 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
58
59 ret = bpf_map__update_elem(skel->maps.pcpu_array_map,
60 &key, sizeof(key), pbuf, cpu * sizeof(buf), 0);
61 ASSERT_OK(ret, "pcpu_array_map update");
62 skel->data->ref--;
63 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
64 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
65 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
66
67 ret = bpf_map__delete_elem(skel->maps.hash_map, &key, sizeof(key), 0);
68 ASSERT_OK(ret, "hash_map delete");
69 skel->data->ref--;
70 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
71 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
72 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
73
74 ret = bpf_map__delete_elem(skel->maps.pcpu_hash_map, &key, sizeof(key), 0);
75 ASSERT_OK(ret, "pcpu_hash_map delete");
76 skel->data->ref--;
77 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
78 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
79 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
80
81 ret = bpf_map__delete_elem(skel->maps.hash_malloc_map, &key, sizeof(key), 0);
82 ASSERT_OK(ret, "hash_malloc_map delete");
83 skel->data->ref--;
84 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
85 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
86 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
87
88 ret = bpf_map__delete_elem(skel->maps.pcpu_hash_malloc_map, &key, sizeof(key), 0);
89 ASSERT_OK(ret, "pcpu_hash_malloc_map delete");
90 skel->data->ref--;
91 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
92 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
93 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
94
95 ret = bpf_map__delete_elem(skel->maps.lru_hash_map, &key, sizeof(key), 0);
96 ASSERT_OK(ret, "lru_hash_map delete");
97 skel->data->ref--;
98 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
99 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
100 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
101
102 ret = bpf_map__delete_elem(skel->maps.lru_pcpu_hash_map, &key, sizeof(key), 0);
103 ASSERT_OK(ret, "lru_pcpu_hash_map delete");
104 skel->data->ref--;
105 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref3), &opts);
106 ASSERT_OK(ret, "test_map_kptr_ref3 refcount");
107 ASSERT_OK(opts.retval, "test_map_kptr_ref3 retval");
108
109 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_ls_map_kptr_ref_del), &lopts);
110 ASSERT_OK(ret, "test_ls_map_kptr_ref_del delete");
111 skel->data->ref--;
112 ASSERT_OK(lopts.retval, "test_ls_map_kptr_ref_del retval");
113
114 free(pbuf);
115exit:
116 map_kptr__destroy(skel);
117}
118
119static int kern_sync_rcu_tasks_trace(struct rcu_tasks_trace_gp *rcu)
120{
121 long gp_seq = READ_ONCE(rcu->bss->gp_seq);
122 LIBBPF_OPTS(bpf_test_run_opts, opts);
123
124 if (!ASSERT_OK(bpf_prog_test_run_opts(bpf_program__fd(rcu->progs.do_call_rcu_tasks_trace),
125 &opts), "do_call_rcu_tasks_trace"))
126 return -EFAULT;
127 if (!ASSERT_OK(opts.retval, "opts.retval == 0"))
128 return -EFAULT;
129 while (gp_seq == READ_ONCE(rcu->bss->gp_seq))
130 sched_yield();
131 return 0;
132}
133
134void serial_test_map_kptr(void)
135{
136 struct rcu_tasks_trace_gp *skel;
137
138 RUN_TESTS(map_kptr_fail);
139
140 skel = rcu_tasks_trace_gp__open_and_load();
141 if (!ASSERT_OK_PTR(skel, "rcu_tasks_trace_gp__open_and_load"))
142 return;
143 if (!ASSERT_OK(rcu_tasks_trace_gp__attach(skel), "rcu_tasks_trace_gp__attach"))
144 goto end;
145
146 if (test__start_subtest("success-map")) {
147 test_map_kptr_success(true);
148
149 ASSERT_OK(kern_sync_rcu_tasks_trace(skel), "sync rcu_tasks_trace");
150 ASSERT_OK(kern_sync_rcu(), "sync rcu");
151 /* Observe refcount dropping to 1 on bpf_map_free_deferred */
152 test_map_kptr_success(false);
153
154 ASSERT_OK(kern_sync_rcu_tasks_trace(skel), "sync rcu_tasks_trace");
155 ASSERT_OK(kern_sync_rcu(), "sync rcu");
156 /* Observe refcount dropping to 1 on synchronous delete elem */
157 test_map_kptr_success(true);
158 }
159
160end:
161 rcu_tasks_trace_gp__destroy(skel);
162 return;
163}
1// SPDX-License-Identifier: GPL-2.0
2#include <test_progs.h>
3#include <network_helpers.h>
4
5#include "map_kptr.skel.h"
6#include "map_kptr_fail.skel.h"
7
8static void test_map_kptr_success(bool test_run)
9{
10 LIBBPF_OPTS(bpf_test_run_opts, opts,
11 .data_in = &pkt_v4,
12 .data_size_in = sizeof(pkt_v4),
13 .repeat = 1,
14 );
15 struct map_kptr *skel;
16 int key = 0, ret;
17 char buf[16];
18
19 skel = map_kptr__open_and_load();
20 if (!ASSERT_OK_PTR(skel, "map_kptr__open_and_load"))
21 return;
22
23 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref), &opts);
24 ASSERT_OK(ret, "test_map_kptr_ref refcount");
25 ASSERT_OK(opts.retval, "test_map_kptr_ref retval");
26 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_map_kptr_ref2), &opts);
27 ASSERT_OK(ret, "test_map_kptr_ref2 refcount");
28 ASSERT_OK(opts.retval, "test_map_kptr_ref2 retval");
29
30 if (test_run)
31 goto exit;
32
33 ret = bpf_map__update_elem(skel->maps.array_map,
34 &key, sizeof(key), buf, sizeof(buf), 0);
35 ASSERT_OK(ret, "array_map update");
36 ret = bpf_map__update_elem(skel->maps.array_map,
37 &key, sizeof(key), buf, sizeof(buf), 0);
38 ASSERT_OK(ret, "array_map update2");
39
40 ret = bpf_map__update_elem(skel->maps.hash_map,
41 &key, sizeof(key), buf, sizeof(buf), 0);
42 ASSERT_OK(ret, "hash_map update");
43 ret = bpf_map__delete_elem(skel->maps.hash_map, &key, sizeof(key), 0);
44 ASSERT_OK(ret, "hash_map delete");
45
46 ret = bpf_map__update_elem(skel->maps.hash_malloc_map,
47 &key, sizeof(key), buf, sizeof(buf), 0);
48 ASSERT_OK(ret, "hash_malloc_map update");
49 ret = bpf_map__delete_elem(skel->maps.hash_malloc_map, &key, sizeof(key), 0);
50 ASSERT_OK(ret, "hash_malloc_map delete");
51
52 ret = bpf_map__update_elem(skel->maps.lru_hash_map,
53 &key, sizeof(key), buf, sizeof(buf), 0);
54 ASSERT_OK(ret, "lru_hash_map update");
55 ret = bpf_map__delete_elem(skel->maps.lru_hash_map, &key, sizeof(key), 0);
56 ASSERT_OK(ret, "lru_hash_map delete");
57
58exit:
59 map_kptr__destroy(skel);
60}
61
62void test_map_kptr(void)
63{
64 if (test__start_subtest("success")) {
65 test_map_kptr_success(false);
66 /* Do test_run twice, so that we see refcount going back to 1
67 * after we leave it in map from first iteration.
68 */
69 test_map_kptr_success(true);
70 }
71
72 RUN_TESTS(map_kptr_fail);
73}