1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2022 Meta Platforms, Inc. and affiliates.*/
3
4 #define _GNU_SOURCE
5 #include <unistd.h>
6 #include <sys/syscall.h>
7 #include <sys/types.h>
8 #include <test_progs.h>
9 #include <bpf/btf.h>
10 #include "rcu_read_lock.skel.h"
11 #include "cgroup_helpers.h"
12
13 static unsigned long long cgroup_id;
14
test_success(void)15 static void test_success(void)
16 {
17 struct rcu_read_lock *skel;
18 int err;
19
20 skel = rcu_read_lock__open();
21 if (!ASSERT_OK_PTR(skel, "skel_open"))
22 return;
23
24 skel->bss->target_pid = sys_gettid();
25
26 bpf_program__set_autoload(skel->progs.get_cgroup_id, true);
27 bpf_program__set_autoload(skel->progs.task_succ, true);
28 bpf_program__set_autoload(skel->progs.two_regions, true);
29 bpf_program__set_autoload(skel->progs.non_sleepable_1, true);
30 bpf_program__set_autoload(skel->progs.non_sleepable_2, true);
31 bpf_program__set_autoload(skel->progs.task_trusted_non_rcuptr, true);
32 bpf_program__set_autoload(skel->progs.rcu_read_lock_subprog, true);
33 bpf_program__set_autoload(skel->progs.rcu_read_lock_global_subprog, true);
34 bpf_program__set_autoload(skel->progs.rcu_read_lock_subprog_lock, true);
35 bpf_program__set_autoload(skel->progs.rcu_read_lock_subprog_unlock, true);
36 err = rcu_read_lock__load(skel);
37 if (!ASSERT_OK(err, "skel_load"))
38 goto out;
39
40 err = rcu_read_lock__attach(skel);
41 if (!ASSERT_OK(err, "skel_attach"))
42 goto out;
43
44 syscall(SYS_getpgid);
45
46 ASSERT_EQ(skel->bss->task_storage_val, 2, "task_storage_val");
47 ASSERT_EQ(skel->bss->cgroup_id, cgroup_id, "cgroup_id");
48 out:
49 rcu_read_lock__destroy(skel);
50 }
51
test_rcuptr_acquire(void)52 static void test_rcuptr_acquire(void)
53 {
54 struct rcu_read_lock *skel;
55 int err;
56
57 skel = rcu_read_lock__open();
58 if (!ASSERT_OK_PTR(skel, "skel_open"))
59 return;
60
61 skel->bss->target_pid = sys_gettid();
62
63 bpf_program__set_autoload(skel->progs.task_acquire, true);
64 err = rcu_read_lock__load(skel);
65 if (!ASSERT_OK(err, "skel_load"))
66 goto out;
67
68 err = rcu_read_lock__attach(skel);
69 ASSERT_OK(err, "skel_attach");
70 out:
71 rcu_read_lock__destroy(skel);
72 }
73
74 static const char * const inproper_region_tests[] = {
75 "miss_lock",
76 "no_lock",
77 "miss_unlock",
78 "non_sleepable_rcu_mismatch",
79 "inproper_sleepable_helper",
80 "inproper_sleepable_kfunc",
81 "nested_rcu_region",
82 "rcu_read_lock_global_subprog_lock",
83 "rcu_read_lock_global_subprog_unlock",
84 "rcu_read_lock_sleepable_helper_global_subprog",
85 "rcu_read_lock_sleepable_kfunc_global_subprog",
86 "rcu_read_lock_sleepable_global_subprog_indirect",
87 };
88
test_inproper_region(void)89 static void test_inproper_region(void)
90 {
91 struct rcu_read_lock *skel;
92 struct bpf_program *prog;
93 int i, err;
94
95 for (i = 0; i < ARRAY_SIZE(inproper_region_tests); i++) {
96 skel = rcu_read_lock__open();
97 if (!ASSERT_OK_PTR(skel, "skel_open"))
98 return;
99
100 prog = bpf_object__find_program_by_name(skel->obj, inproper_region_tests[i]);
101 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
102 goto out;
103 bpf_program__set_autoload(prog, true);
104 err = rcu_read_lock__load(skel);
105 ASSERT_ERR(err, "skel_load");
106 out:
107 rcu_read_lock__destroy(skel);
108 }
109 }
110
111 static const char * const rcuptr_misuse_tests[] = {
112 "task_untrusted_rcuptr",
113 "cross_rcu_region",
114 };
115
test_rcuptr_misuse(void)116 static void test_rcuptr_misuse(void)
117 {
118 struct rcu_read_lock *skel;
119 struct bpf_program *prog;
120 int i, err;
121
122 for (i = 0; i < ARRAY_SIZE(rcuptr_misuse_tests); i++) {
123 skel = rcu_read_lock__open();
124 if (!ASSERT_OK_PTR(skel, "skel_open"))
125 return;
126
127 prog = bpf_object__find_program_by_name(skel->obj, rcuptr_misuse_tests[i]);
128 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))
129 goto out;
130 bpf_program__set_autoload(prog, true);
131 err = rcu_read_lock__load(skel);
132 ASSERT_ERR(err, "skel_load");
133 out:
134 rcu_read_lock__destroy(skel);
135 }
136 }
137
test_rcu_read_lock(void)138 void test_rcu_read_lock(void)
139 {
140 int cgroup_fd;
141
142 cgroup_fd = test__join_cgroup("/rcu_read_lock");
143 if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup /rcu_read_lock"))
144 goto out;
145
146 cgroup_id = get_cgroup_id("/rcu_read_lock");
147 if (test__start_subtest("success"))
148 test_success();
149 if (test__start_subtest("rcuptr_acquire"))
150 test_rcuptr_acquire();
151 if (test__start_subtest("negative_tests_inproper_region"))
152 test_inproper_region();
153 if (test__start_subtest("negative_tests_rcuptr_misuse"))
154 test_rcuptr_misuse();
155 close(cgroup_fd);
156 out:;
157 }
158