Merge tag 'pm-5.2-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[sfrench/cifs-2.6.git] / samples / bpf / test_cgrp2_attach2.c
1 /* eBPF example program:
2  *
3  * - Creates arraymap in kernel with 4 bytes keys and 8 byte values
4  *
5  * - Loads eBPF program
6  *
7  *   The eBPF program accesses the map passed in to store two pieces of
8  *   information. The number of invocations of the program, which maps
9  *   to the number of packets received, is stored to key 0. Key 1 is
10  *   incremented on each iteration by the number of bytes stored in
11  *   the skb. The program also stores the number of received bytes
12  *   in the cgroup storage.
13  *
14  * - Attaches the new program to a cgroup using BPF_PROG_ATTACH
15  *
16  * - Every second, reads map[0] and map[1] to see how many bytes and
17  *   packets were seen on any socket of tasks in the given cgroup.
18  */
19
20 #define _GNU_SOURCE
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <assert.h>
25 #include <sys/resource.h>
26 #include <sys/time.h>
27 #include <unistd.h>
28
29 #include <linux/bpf.h>
30 #include <bpf/bpf.h>
31
32 #include "bpf_insn.h"
33 #include "bpf_rlimit.h"
34 #include "cgroup_helpers.h"
35
36 #define FOO             "/foo"
37 #define BAR             "/foo/bar/"
38 #define PING_CMD        "ping -c1 -w1 127.0.0.1 > /dev/null"
39
40 char bpf_log_buf[BPF_LOG_BUF_SIZE];
41
42 static int prog_load(int verdict)
43 {
44         int ret;
45         struct bpf_insn prog[] = {
46                 BPF_MOV64_IMM(BPF_REG_0, verdict), /* r0 = verdict */
47                 BPF_EXIT_INSN(),
48         };
49         size_t insns_cnt = sizeof(prog) / sizeof(struct bpf_insn);
50
51         ret = bpf_load_program(BPF_PROG_TYPE_CGROUP_SKB,
52                                prog, insns_cnt, "GPL", 0,
53                                bpf_log_buf, BPF_LOG_BUF_SIZE);
54
55         if (ret < 0) {
56                 log_err("Loading program");
57                 printf("Output from verifier:\n%s\n-------\n", bpf_log_buf);
58                 return 0;
59         }
60         return ret;
61 }
62
63 static int test_foo_bar(void)
64 {
65         int drop_prog, allow_prog, foo = 0, bar = 0, rc = 0;
66
67         allow_prog = prog_load(1);
68         if (!allow_prog)
69                 goto err;
70
71         drop_prog = prog_load(0);
72         if (!drop_prog)
73                 goto err;
74
75         if (setup_cgroup_environment())
76                 goto err;
77
78         /* Create cgroup /foo, get fd, and join it */
79         foo = create_and_get_cgroup(FOO);
80         if (foo < 0)
81                 goto err;
82
83         if (join_cgroup(FOO))
84                 goto err;
85
86         if (bpf_prog_attach(drop_prog, foo, BPF_CGROUP_INET_EGRESS,
87                             BPF_F_ALLOW_OVERRIDE)) {
88                 log_err("Attaching prog to /foo");
89                 goto err;
90         }
91
92         printf("Attached DROP prog. This ping in cgroup /foo should fail...\n");
93         assert(system(PING_CMD) != 0);
94
95         /* Create cgroup /foo/bar, get fd, and join it */
96         bar = create_and_get_cgroup(BAR);
97         if (bar < 0)
98                 goto err;
99
100         if (join_cgroup(BAR))
101                 goto err;
102
103         printf("Attached DROP prog. This ping in cgroup /foo/bar should fail...\n");
104         assert(system(PING_CMD) != 0);
105
106         if (bpf_prog_attach(allow_prog, bar, BPF_CGROUP_INET_EGRESS,
107                             BPF_F_ALLOW_OVERRIDE)) {
108                 log_err("Attaching prog to /foo/bar");
109                 goto err;
110         }
111
112         printf("Attached PASS prog. This ping in cgroup /foo/bar should pass...\n");
113         assert(system(PING_CMD) == 0);
114
115         if (bpf_prog_detach(bar, BPF_CGROUP_INET_EGRESS)) {
116                 log_err("Detaching program from /foo/bar");
117                 goto err;
118         }
119
120         printf("Detached PASS from /foo/bar while DROP is attached to /foo.\n"
121                "This ping in cgroup /foo/bar should fail...\n");
122         assert(system(PING_CMD) != 0);
123
124         if (bpf_prog_attach(allow_prog, bar, BPF_CGROUP_INET_EGRESS,
125                             BPF_F_ALLOW_OVERRIDE)) {
126                 log_err("Attaching prog to /foo/bar");
127                 goto err;
128         }
129
130         if (bpf_prog_detach(foo, BPF_CGROUP_INET_EGRESS)) {
131                 log_err("Detaching program from /foo");
132                 goto err;
133         }
134
135         printf("Attached PASS from /foo/bar and detached DROP from /foo.\n"
136                "This ping in cgroup /foo/bar should pass...\n");
137         assert(system(PING_CMD) == 0);
138
139         if (bpf_prog_attach(allow_prog, bar, BPF_CGROUP_INET_EGRESS,
140                             BPF_F_ALLOW_OVERRIDE)) {
141                 log_err("Attaching prog to /foo/bar");
142                 goto err;
143         }
144
145         if (!bpf_prog_attach(allow_prog, bar, BPF_CGROUP_INET_EGRESS, 0)) {
146                 errno = 0;
147                 log_err("Unexpected success attaching prog to /foo/bar");
148                 goto err;
149         }
150
151         if (bpf_prog_detach(bar, BPF_CGROUP_INET_EGRESS)) {
152                 log_err("Detaching program from /foo/bar");
153                 goto err;
154         }
155
156         if (!bpf_prog_detach(foo, BPF_CGROUP_INET_EGRESS)) {
157                 errno = 0;
158                 log_err("Unexpected success in double detach from /foo");
159                 goto err;
160         }
161
162         if (bpf_prog_attach(allow_prog, foo, BPF_CGROUP_INET_EGRESS, 0)) {
163                 log_err("Attaching non-overridable prog to /foo");
164                 goto err;
165         }
166
167         if (!bpf_prog_attach(allow_prog, bar, BPF_CGROUP_INET_EGRESS, 0)) {
168                 errno = 0;
169                 log_err("Unexpected success attaching non-overridable prog to /foo/bar");
170                 goto err;
171         }
172
173         if (!bpf_prog_attach(allow_prog, bar, BPF_CGROUP_INET_EGRESS,
174                              BPF_F_ALLOW_OVERRIDE)) {
175                 errno = 0;
176                 log_err("Unexpected success attaching overridable prog to /foo/bar");
177                 goto err;
178         }
179
180         if (!bpf_prog_attach(allow_prog, foo, BPF_CGROUP_INET_EGRESS,
181                              BPF_F_ALLOW_OVERRIDE)) {
182                 errno = 0;
183                 log_err("Unexpected success attaching overridable prog to /foo");
184                 goto err;
185         }
186
187         if (bpf_prog_attach(drop_prog, foo, BPF_CGROUP_INET_EGRESS, 0)) {
188                 log_err("Attaching different non-overridable prog to /foo");
189                 goto err;
190         }
191
192         goto out;
193
194 err:
195         rc = 1;
196
197 out:
198         close(foo);
199         close(bar);
200         cleanup_cgroup_environment();
201         if (!rc)
202                 printf("### override:PASS\n");
203         else
204                 printf("### override:FAIL\n");
205         return rc;
206 }
207
208 static int map_fd = -1;
209
210 static int prog_load_cnt(int verdict, int val)
211 {
212         int cgroup_storage_fd, percpu_cgroup_storage_fd;
213
214         if (map_fd < 0)
215                 map_fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, 4, 8, 1, 0);
216         if (map_fd < 0) {
217                 printf("failed to create map '%s'\n", strerror(errno));
218                 return -1;
219         }
220
221         cgroup_storage_fd = bpf_create_map(BPF_MAP_TYPE_CGROUP_STORAGE,
222                                 sizeof(struct bpf_cgroup_storage_key), 8, 0, 0);
223         if (cgroup_storage_fd < 0) {
224                 printf("failed to create map '%s'\n", strerror(errno));
225                 return -1;
226         }
227
228         percpu_cgroup_storage_fd = bpf_create_map(
229                 BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE,
230                 sizeof(struct bpf_cgroup_storage_key), 8, 0, 0);
231         if (percpu_cgroup_storage_fd < 0) {
232                 printf("failed to create map '%s'\n", strerror(errno));
233                 return -1;
234         }
235
236         struct bpf_insn prog[] = {
237                 BPF_MOV32_IMM(BPF_REG_0, 0),
238                 BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* *(u32 *)(fp - 4) = r0 */
239                 BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
240                 BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */
241                 BPF_LD_MAP_FD(BPF_REG_1, map_fd),
242                 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem),
243                 BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2),
244                 BPF_MOV64_IMM(BPF_REG_1, val), /* r1 = 1 */
245                 BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_DW, BPF_REG_0, BPF_REG_1, 0, 0), /* xadd r0 += r1 */
246
247                 BPF_LD_MAP_FD(BPF_REG_1, cgroup_storage_fd),
248                 BPF_MOV64_IMM(BPF_REG_2, 0),
249                 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_local_storage),
250                 BPF_MOV64_IMM(BPF_REG_1, val),
251                 BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_W, BPF_REG_0, BPF_REG_1, 0, 0),
252
253                 BPF_LD_MAP_FD(BPF_REG_1, percpu_cgroup_storage_fd),
254                 BPF_MOV64_IMM(BPF_REG_2, 0),
255                 BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_local_storage),
256                 BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_0, 0),
257                 BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 0x1),
258                 BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_3, 0),
259
260                 BPF_MOV64_IMM(BPF_REG_0, verdict), /* r0 = verdict */
261                 BPF_EXIT_INSN(),
262         };
263         size_t insns_cnt = sizeof(prog) / sizeof(struct bpf_insn);
264         int ret;
265
266         ret = bpf_load_program(BPF_PROG_TYPE_CGROUP_SKB,
267                                prog, insns_cnt, "GPL", 0,
268                                bpf_log_buf, BPF_LOG_BUF_SIZE);
269
270         if (ret < 0) {
271                 log_err("Loading program");
272                 printf("Output from verifier:\n%s\n-------\n", bpf_log_buf);
273                 return 0;
274         }
275         close(cgroup_storage_fd);
276         return ret;
277 }
278
279
280 static int test_multiprog(void)
281 {
282         __u32 prog_ids[4], prog_cnt = 0, attach_flags, saved_prog_id;
283         int cg1 = 0, cg2 = 0, cg3 = 0, cg4 = 0, cg5 = 0, key = 0;
284         int drop_prog, allow_prog[6] = {}, rc = 0;
285         unsigned long long value;
286         int i = 0;
287
288         for (i = 0; i < 6; i++) {
289                 allow_prog[i] = prog_load_cnt(1, 1 << i);
290                 if (!allow_prog[i])
291                         goto err;
292         }
293         drop_prog = prog_load_cnt(0, 1);
294         if (!drop_prog)
295                 goto err;
296
297         if (setup_cgroup_environment())
298                 goto err;
299
300         cg1 = create_and_get_cgroup("/cg1");
301         if (cg1 < 0)
302                 goto err;
303         cg2 = create_and_get_cgroup("/cg1/cg2");
304         if (cg2 < 0)
305                 goto err;
306         cg3 = create_and_get_cgroup("/cg1/cg2/cg3");
307         if (cg3 < 0)
308                 goto err;
309         cg4 = create_and_get_cgroup("/cg1/cg2/cg3/cg4");
310         if (cg4 < 0)
311                 goto err;
312         cg5 = create_and_get_cgroup("/cg1/cg2/cg3/cg4/cg5");
313         if (cg5 < 0)
314                 goto err;
315
316         if (join_cgroup("/cg1/cg2/cg3/cg4/cg5"))
317                 goto err;
318
319         if (bpf_prog_attach(allow_prog[0], cg1, BPF_CGROUP_INET_EGRESS,
320                             BPF_F_ALLOW_MULTI)) {
321                 log_err("Attaching prog to cg1");
322                 goto err;
323         }
324         if (!bpf_prog_attach(allow_prog[0], cg1, BPF_CGROUP_INET_EGRESS,
325                              BPF_F_ALLOW_MULTI)) {
326                 log_err("Unexpected success attaching the same prog to cg1");
327                 goto err;
328         }
329         if (bpf_prog_attach(allow_prog[1], cg1, BPF_CGROUP_INET_EGRESS,
330                             BPF_F_ALLOW_MULTI)) {
331                 log_err("Attaching prog2 to cg1");
332                 goto err;
333         }
334         if (bpf_prog_attach(allow_prog[2], cg2, BPF_CGROUP_INET_EGRESS,
335                             BPF_F_ALLOW_OVERRIDE)) {
336                 log_err("Attaching prog to cg2");
337                 goto err;
338         }
339         if (bpf_prog_attach(allow_prog[3], cg3, BPF_CGROUP_INET_EGRESS,
340                             BPF_F_ALLOW_MULTI)) {
341                 log_err("Attaching prog to cg3");
342                 goto err;
343         }
344         if (bpf_prog_attach(allow_prog[4], cg4, BPF_CGROUP_INET_EGRESS,
345                             BPF_F_ALLOW_OVERRIDE)) {
346                 log_err("Attaching prog to cg4");
347                 goto err;
348         }
349         if (bpf_prog_attach(allow_prog[5], cg5, BPF_CGROUP_INET_EGRESS, 0)) {
350                 log_err("Attaching prog to cg5");
351                 goto err;
352         }
353         assert(system(PING_CMD) == 0);
354         assert(bpf_map_lookup_elem(map_fd, &key, &value) == 0);
355         assert(value == 1 + 2 + 8 + 32);
356
357         /* query the number of effective progs in cg5 */
358         assert(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS, BPF_F_QUERY_EFFECTIVE,
359                               NULL, NULL, &prog_cnt) == 0);
360         assert(prog_cnt == 4);
361         /* retrieve prog_ids of effective progs in cg5 */
362         assert(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS, BPF_F_QUERY_EFFECTIVE,
363                               &attach_flags, prog_ids, &prog_cnt) == 0);
364         assert(prog_cnt == 4);
365         assert(attach_flags == 0);
366         saved_prog_id = prog_ids[0];
367         /* check enospc handling */
368         prog_ids[0] = 0;
369         prog_cnt = 2;
370         assert(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS, BPF_F_QUERY_EFFECTIVE,
371                               &attach_flags, prog_ids, &prog_cnt) == -1 &&
372                errno == ENOSPC);
373         assert(prog_cnt == 4);
374         /* check that prog_ids are returned even when buffer is too small */
375         assert(prog_ids[0] == saved_prog_id);
376         /* retrieve prog_id of single attached prog in cg5 */
377         prog_ids[0] = 0;
378         assert(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS, 0,
379                               NULL, prog_ids, &prog_cnt) == 0);
380         assert(prog_cnt == 1);
381         assert(prog_ids[0] == saved_prog_id);
382
383         /* detach bottom program and ping again */
384         if (bpf_prog_detach2(-1, cg5, BPF_CGROUP_INET_EGRESS)) {
385                 log_err("Detaching prog from cg5");
386                 goto err;
387         }
388         value = 0;
389         assert(bpf_map_update_elem(map_fd, &key, &value, 0) == 0);
390         assert(system(PING_CMD) == 0);
391         assert(bpf_map_lookup_elem(map_fd, &key, &value) == 0);
392         assert(value == 1 + 2 + 8 + 16);
393
394         /* detach 3rd from bottom program and ping again */
395         errno = 0;
396         if (!bpf_prog_detach2(0, cg3, BPF_CGROUP_INET_EGRESS)) {
397                 log_err("Unexpected success on detach from cg3");
398                 goto err;
399         }
400         if (bpf_prog_detach2(allow_prog[3], cg3, BPF_CGROUP_INET_EGRESS)) {
401                 log_err("Detaching from cg3");
402                 goto err;
403         }
404         value = 0;
405         assert(bpf_map_update_elem(map_fd, &key, &value, 0) == 0);
406         assert(system(PING_CMD) == 0);
407         assert(bpf_map_lookup_elem(map_fd, &key, &value) == 0);
408         assert(value == 1 + 2 + 16);
409
410         /* detach 2nd from bottom program and ping again */
411         if (bpf_prog_detach2(-1, cg4, BPF_CGROUP_INET_EGRESS)) {
412                 log_err("Detaching prog from cg4");
413                 goto err;
414         }
415         value = 0;
416         assert(bpf_map_update_elem(map_fd, &key, &value, 0) == 0);
417         assert(system(PING_CMD) == 0);
418         assert(bpf_map_lookup_elem(map_fd, &key, &value) == 0);
419         assert(value == 1 + 2 + 4);
420
421         prog_cnt = 4;
422         assert(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS, BPF_F_QUERY_EFFECTIVE,
423                               &attach_flags, prog_ids, &prog_cnt) == 0);
424         assert(prog_cnt == 3);
425         assert(attach_flags == 0);
426         assert(bpf_prog_query(cg5, BPF_CGROUP_INET_EGRESS, 0,
427                               NULL, prog_ids, &prog_cnt) == 0);
428         assert(prog_cnt == 0);
429         goto out;
430 err:
431         rc = 1;
432
433 out:
434         for (i = 0; i < 6; i++)
435                 if (allow_prog[i] > 0)
436                         close(allow_prog[i]);
437         close(cg1);
438         close(cg2);
439         close(cg3);
440         close(cg4);
441         close(cg5);
442         cleanup_cgroup_environment();
443         if (!rc)
444                 printf("### multi:PASS\n");
445         else
446                 printf("### multi:FAIL\n");
447         return rc;
448 }
449
450 int main(int argc, char **argv)
451 {
452         int rc = 0;
453
454         rc = test_foo_bar();
455         if (rc)
456                 return rc;
457
458         return test_multiprog();
459 }