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 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.nested_rcu_region, true); 32 bpf_program__set_autoload(skel->progs.task_trusted_non_rcuptr, true); 33 bpf_program__set_autoload(skel->progs.rcu_read_lock_subprog, true); 34 bpf_program__set_autoload(skel->progs.rcu_read_lock_global_subprog, true); 35 bpf_program__set_autoload(skel->progs.rcu_read_lock_subprog_lock, true); 36 bpf_program__set_autoload(skel->progs.rcu_read_lock_subprog_unlock, true); 37 err = rcu_read_lock__load(skel); 38 if (!ASSERT_OK(err, "skel_load")) 39 goto out; 40 41 err = rcu_read_lock__attach(skel); 42 if (!ASSERT_OK(err, "skel_attach")) 43 goto out; 44 45 syscall(SYS_getpgid); 46 47 ASSERT_EQ(skel->bss->task_storage_val, 2, "task_storage_val"); 48 ASSERT_EQ(skel->bss->cgroup_id, cgroup_id, "cgroup_id"); 49 out: 50 rcu_read_lock__destroy(skel); 51 } 52 53 static void test_rcuptr_acquire(void) 54 { 55 struct rcu_read_lock *skel; 56 int err; 57 58 skel = rcu_read_lock__open(); 59 if (!ASSERT_OK_PTR(skel, "skel_open")) 60 return; 61 62 skel->bss->target_pid = sys_gettid(); 63 64 bpf_program__set_autoload(skel->progs.task_acquire, true); 65 err = rcu_read_lock__load(skel); 66 if (!ASSERT_OK(err, "skel_load")) 67 goto out; 68 69 err = rcu_read_lock__attach(skel); 70 ASSERT_OK(err, "skel_attach"); 71 out: 72 rcu_read_lock__destroy(skel); 73 } 74 75 static const char * const inproper_region_tests[] = { 76 "miss_lock", 77 "no_lock", 78 "miss_unlock", 79 "non_sleepable_rcu_mismatch", 80 "inproper_sleepable_helper", 81 "inproper_sleepable_kfunc", 82 "nested_rcu_region_unbalanced_1", 83 "nested_rcu_region_unbalanced_2", 84 "rcu_read_lock_global_subprog_lock", 85 "rcu_read_lock_global_subprog_unlock", 86 "rcu_read_lock_sleepable_helper_global_subprog", 87 "rcu_read_lock_sleepable_kfunc_global_subprog", 88 "rcu_read_lock_sleepable_global_subprog_indirect", 89 }; 90 91 static void test_inproper_region(void) 92 { 93 struct rcu_read_lock *skel; 94 struct bpf_program *prog; 95 int i, err; 96 97 for (i = 0; i < ARRAY_SIZE(inproper_region_tests); i++) { 98 skel = rcu_read_lock__open(); 99 if (!ASSERT_OK_PTR(skel, "skel_open")) 100 return; 101 102 prog = bpf_object__find_program_by_name(skel->obj, inproper_region_tests[i]); 103 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name")) 104 goto out; 105 bpf_program__set_autoload(prog, true); 106 err = rcu_read_lock__load(skel); 107 ASSERT_ERR(err, "skel_load"); 108 out: 109 rcu_read_lock__destroy(skel); 110 } 111 } 112 113 static const char * const rcuptr_misuse_tests[] = { 114 "task_untrusted_rcuptr", 115 "cross_rcu_region", 116 }; 117 118 static void test_rcuptr_misuse(void) 119 { 120 struct rcu_read_lock *skel; 121 struct bpf_program *prog; 122 int i, err; 123 124 for (i = 0; i < ARRAY_SIZE(rcuptr_misuse_tests); i++) { 125 skel = rcu_read_lock__open(); 126 if (!ASSERT_OK_PTR(skel, "skel_open")) 127 return; 128 129 prog = bpf_object__find_program_by_name(skel->obj, rcuptr_misuse_tests[i]); 130 if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name")) 131 goto out; 132 bpf_program__set_autoload(prog, true); 133 err = rcu_read_lock__load(skel); 134 ASSERT_ERR(err, "skel_load"); 135 out: 136 rcu_read_lock__destroy(skel); 137 } 138 } 139 140 void test_rcu_read_lock(void) 141 { 142 int cgroup_fd; 143 144 cgroup_fd = test__join_cgroup("/rcu_read_lock"); 145 if (!ASSERT_GE(cgroup_fd, 0, "join_cgroup /rcu_read_lock")) 146 goto out; 147 148 cgroup_id = get_cgroup_id("/rcu_read_lock"); 149 if (test__start_subtest("success")) 150 test_success(); 151 if (test__start_subtest("rcuptr_acquire")) 152 test_rcuptr_acquire(); 153 if (test__start_subtest("negative_tests_inproper_region")) 154 test_inproper_region(); 155 if (test__start_subtest("negative_tests_rcuptr_misuse")) 156 test_rcuptr_misuse(); 157 close(cgroup_fd); 158 out:; 159 } 160