1 // SPDX-License-Identifier: GPL-2.0
2 #include <vmlinux.h>
3 #include <bpf/bpf_tracing.h>
4 #include <bpf/bpf_helpers.h>
5 #include "bpf_experimental.h"
6
7 struct foo {
8 struct bpf_spin_lock lock;
9 int data;
10 };
11
12 struct array_map {
13 __uint(type, BPF_MAP_TYPE_ARRAY);
14 __type(key, int);
15 __type(value, struct foo);
16 __uint(max_entries, 1);
17 } array_map SEC(".maps");
18
19 struct {
20 __uint(type, BPF_MAP_TYPE_ARRAY_OF_MAPS);
21 __uint(max_entries, 1);
22 __type(key, int);
23 __type(value, int);
24 __array(values, struct array_map);
25 } map_of_maps SEC(".maps") = {
26 .values = {
27 [0] = &array_map,
28 },
29 };
30
31 SEC(".data.A") struct bpf_spin_lock lockA;
32 SEC(".data.B") struct bpf_spin_lock lockB;
33
34 SEC("?tc")
35 int lock_id_kptr_preserve(void *ctx)
36 {
37 struct foo *f;
38
39 f = bpf_obj_new(typeof(*f));
40 if (!f)
41 return 0;
42 bpf_this_cpu_ptr(f);
43 return 0;
44 }
45
46 SEC("?tc")
47 int lock_id_global_zero(void *ctx)
48 {
49 bpf_this_cpu_ptr(&lockA);
50 return 0;
51 }
52
53 SEC("?tc")
54 int lock_id_mapval_preserve(void *ctx)
55 {
56 struct foo *f;
57 int key = 0;
58
59 f = bpf_map_lookup_elem(&array_map, &key);
60 if (!f)
61 return 0;
62 bpf_this_cpu_ptr(f);
63 return 0;
64 }
65
66 SEC("?tc")
67 int lock_id_innermapval_preserve(void *ctx)
68 {
69 struct foo *f;
70 int key = 0;
71 void *map;
72
73 map = bpf_map_lookup_elem(&map_of_maps, &key);
74 if (!map)
75 return 0;
76 f = bpf_map_lookup_elem(map, &key);
77 if (!f)
78 return 0;
79 bpf_this_cpu_ptr(f);
80 return 0;
81 }
82
83 #define CHECK(test, A, B) \
84 SEC("?tc") \
85 int lock_id_mismatch_##test(void *ctx) \
86 { \
87 struct foo *f1, *f2, *v, *iv; \
88 int key = 0; \
89 void *map; \
90 \
91 map = bpf_map_lookup_elem(&map_of_maps, &key); \
92 if (!map) \
93 return 0; \
94 iv = bpf_map_lookup_elem(map, &key); \
95 if (!iv) \
96 return 0; \
97 v = bpf_map_lookup_elem(&array_map, &key); \
98 if (!v) \
99 return 0; \
100 f1 = bpf_obj_new(typeof(*f1)); \
101 if (!f1) \
102 return 0; \
103 f2 = bpf_obj_new(typeof(*f2)); \
104 if (!f2) { \
105 bpf_obj_drop(f1); \
106 return 0; \
107 } \
108 bpf_spin_lock(A); \
109 bpf_spin_unlock(B); \
110 return 0; \
111 }
112
113 CHECK(kptr_kptr, &f1->lock, &f2->lock);
114 CHECK(kptr_global, &f1->lock, &lockA);
115 CHECK(kptr_mapval, &f1->lock, &v->lock);
116 CHECK(kptr_innermapval, &f1->lock, &iv->lock);
117
118 CHECK(global_global, &lockA, &lockB);
119 CHECK(global_kptr, &lockA, &f1->lock);
120 CHECK(global_mapval, &lockA, &v->lock);
121 CHECK(global_innermapval, &lockA, &iv->lock);
122
123 SEC("?tc")
124 int lock_id_mismatch_mapval_mapval(void *ctx)
125 {
126 struct foo *f1, *f2;
127 int key = 0;
128
129 f1 = bpf_map_lookup_elem(&array_map, &key);
130 if (!f1)
131 return 0;
132 f2 = bpf_map_lookup_elem(&array_map, &key);
133 if (!f2)
134 return 0;
135
136 bpf_spin_lock(&f1->lock);
137 f1->data = 42;
138 bpf_spin_unlock(&f2->lock);
139
140 return 0;
141 }
142
143 CHECK(mapval_kptr, &v->lock, &f1->lock);
144 CHECK(mapval_global, &v->lock, &lockB);
145 CHECK(mapval_innermapval, &v->lock, &iv->lock);
146
147 SEC("?tc")
148 int lock_id_mismatch_innermapval_innermapval1(void *ctx)
149 {
150 struct foo *f1, *f2;
151 int key = 0;
152 void *map;
153
154 map = bpf_map_lookup_elem(&map_of_maps, &key);
155 if (!map)
156 return 0;
157 f1 = bpf_map_lookup_elem(map, &key);
158 if (!f1)
159 return 0;
160 f2 = bpf_map_lookup_elem(map, &key);
161 if (!f2)
162 return 0;
163
164 bpf_spin_lock(&f1->lock);
165 f1->data = 42;
166 bpf_spin_unlock(&f2->lock);
167
168 return 0;
169 }
170
171 SEC("?tc")
172 int lock_id_mismatch_innermapval_innermapval2(void *ctx)
173 {
174 struct foo *f1, *f2;
175 int key = 0;
176 void *map;
177
178 map = bpf_map_lookup_elem(&map_of_maps, &key);
179 if (!map)
180 return 0;
181 f1 = bpf_map_lookup_elem(map, &key);
182 if (!f1)
183 return 0;
184 map = bpf_map_lookup_elem(&map_of_maps, &key);
185 if (!map)
186 return 0;
187 f2 = bpf_map_lookup_elem(map, &key);
188 if (!f2)
189 return 0;
190
191 bpf_spin_lock(&f1->lock);
192 f1->data = 42;
193 bpf_spin_unlock(&f2->lock);
194
195 return 0;
196 }
197
198 CHECK(innermapval_kptr, &iv->lock, &f1->lock);
199 CHECK(innermapval_global, &iv->lock, &lockA);
200 CHECK(innermapval_mapval, &iv->lock, &v->lock);
201
202 #undef CHECK
203
204 __noinline
205 int global_subprog(struct __sk_buff *ctx)
206 {
207 volatile int ret = 0;
208
209 if (ctx->protocol)
210 ret += ctx->protocol;
211 return ret + ctx->mark;
212 }
213
214 __noinline
215 static int static_subprog_call_global(struct __sk_buff *ctx)
216 {
217 volatile int ret = 0;
218
219 if (ctx->protocol)
220 return ret;
221 return ret + ctx->len + global_subprog(ctx);
222 }
223
224 SEC("?tc")
225 int lock_global_subprog_call1(struct __sk_buff *ctx)
226 {
227 int ret = 0;
228
229 bpf_spin_lock(&lockA);
230 if (ctx->mark == 42)
231 ret = global_subprog(ctx);
232 bpf_spin_unlock(&lockA);
233 return ret;
234 }
235
236 SEC("?tc")
237 int lock_global_subprog_call2(struct __sk_buff *ctx)
238 {
239 int ret = 0;
240
241 bpf_spin_lock(&lockA);
242 if (ctx->mark == 42)
243 ret = static_subprog_call_global(ctx);
244 bpf_spin_unlock(&lockA);
245 return ret;
246 }
247
248 char _license[] SEC("license") = "GPL";
249
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.