1 #include "bpf_experimental.h" 2 #include "bpf_misc.h" 3 4 struct val_t { 5 long b, c, d; 6 }; 7 8 struct val2_t { 9 long b; 10 }; 11 12 struct val_with_ptr_t { 13 char *p; 14 }; 15 16 struct val_with_rb_root_t { 17 struct bpf_spin_lock lock; 18 }; 19 20 struct val_600b_t { 21 char b[600]; 22 }; 23 24 struct elem { 25 long sum; 26 struct val_t __percpu_kptr *pc; 27 struct val_t __percpu_kptr *pc2; 28 }; 29 30 struct { 31 __uint(type, BPF_MAP_TYPE_ARRAY); 32 __uint(max_entries, 1); 33 __type(key, int); 34 __type(value, struct elem); 35 } array SEC(".maps"); 36 37 struct kernel_percpu_elem { 38 struct task_struct __percpu_kptr *task; 39 }; 40 41 struct { 42 __uint(type, BPF_MAP_TYPE_ARRAY); 43 __uint(max_entries, 1); 44 __type(key, int); 45 __type(value, struct kernel_percpu_elem); 46 } kernel_percpu_array SEC(".maps"); 47 48 struct task_struct *bpf_task_from_pid(s32 pid) __ksym; 49 void bpf_task_release(struct task_struct *p) __ksym; 50 void bpf_rcu_read_lock(void) __ksym; 51 void bpf_rcu_read_unlock(void) __ksym; 52 53 long ret; 54 55 SEC("?fentry/bpf_fentry_test1") 56 __failure __msg("store to referenced kptr disallowed") 57 int BPF_PROG(test_array_map_1) 58 { 59 struct val_t __percpu_kptr *p; 60 struct elem *e; 61 int index = 0; 62 63 e = bpf_map_lookup_elem(&array, &index); 64 if (!e) 65 return 0; 66 67 p = bpf_percpu_obj_new(struct val_t); 68 if (!p) 69 return 0; 70 71 p = bpf_kptr_xchg(&e->pc, p); 72 if (p) 73 bpf_percpu_obj_drop(p); 74 75 e->pc = (struct val_t __percpu_kptr *)ret; 76 return 0; 77 } 78 79 SEC("?fentry/bpf_fentry_test1") 80 __failure __msg("invalid kptr access, R2 type=percpu_ptr_val2_t expected=ptr_val_t") 81 int BPF_PROG(test_array_map_2) 82 { 83 struct val2_t __percpu_kptr *p2; 84 struct val_t __percpu_kptr *p; 85 struct elem *e; 86 int index = 0; 87 88 e = bpf_map_lookup_elem(&array, &index); 89 if (!e) 90 return 0; 91 92 p2 = bpf_percpu_obj_new(struct val2_t); 93 if (!p2) 94 return 0; 95 96 p = bpf_kptr_xchg(&e->pc, p2); 97 if (p) 98 bpf_percpu_obj_drop(p); 99 100 return 0; 101 } 102 103 SEC("?fentry.s/bpf_fentry_test1") 104 __failure __msg("R1 type=scalar expected=percpu_ptr_, percpu_rcu_ptr_, percpu_trusted_ptr_") 105 int BPF_PROG(test_array_map_3) 106 { 107 struct val_t __percpu_kptr *p, *p1; 108 struct val_t *v; 109 struct elem *e; 110 int index = 0; 111 112 e = bpf_map_lookup_elem(&array, &index); 113 if (!e) 114 return 0; 115 116 p = bpf_percpu_obj_new(struct val_t); 117 if (!p) 118 return 0; 119 120 p1 = bpf_kptr_xchg(&e->pc, p); 121 if (p1) 122 bpf_percpu_obj_drop(p1); 123 124 v = bpf_this_cpu_ptr(p); 125 ret = v->b; 126 return 0; 127 } 128 129 SEC("?fentry.s/bpf_fentry_test1") 130 __failure __msg("Possibly NULL pointer passed to trusted R1") 131 int BPF_PROG(reject_nullable_percpu_xchg_alias) 132 { 133 struct val_t __percpu_kptr *p1, *p2, *old; 134 struct val_t *v; 135 struct elem *e; 136 int index = 0; 137 138 e = bpf_map_lookup_elem(&array, &index); 139 if (!e) 140 return 0; 141 142 p1 = bpf_percpu_obj_new(struct val_t); 143 p2 = bpf_percpu_obj_new(struct val_t); 144 145 bpf_rcu_read_lock(); 146 old = bpf_kptr_xchg(&e->pc, p1); 147 if (old) 148 bpf_percpu_obj_drop(old); 149 old = bpf_kptr_xchg(&e->pc2, p2); 150 if (old) 151 bpf_percpu_obj_drop(old); 152 153 if (p1) { 154 v = bpf_this_cpu_ptr(p2); 155 v->b = 1; 156 } 157 bpf_rcu_read_unlock(); 158 return 0; 159 } 160 161 SEC("?fentry.s/bpf_fentry_test1") 162 __failure __msg("R1 expected for bpf_percpu_obj_drop()") 163 int BPF_PROG(test_array_map_4) 164 { 165 struct val_t __percpu_kptr *p; 166 167 p = bpf_percpu_obj_new(struct val_t); 168 if (!p) 169 return 0; 170 171 bpf_obj_drop(p); 172 return 0; 173 } 174 175 SEC("?fentry.s/bpf_fentry_test1") 176 __failure __msg("R1 expected for bpf_obj_drop()") 177 int BPF_PROG(test_array_map_5) 178 { 179 struct val_t *p; 180 181 p = bpf_obj_new(struct val_t); 182 if (!p) 183 return 0; 184 185 bpf_percpu_obj_drop(p); 186 return 0; 187 } 188 189 SEC("?syscall") 190 __failure __msg("invalid kptr access, R2 type=trusted_ptr_ expected=ptr_task_struct") 191 int reject_kernel_ptr_into_percpu_kptr(void *ctx) 192 { 193 struct kernel_percpu_elem *e; 194 struct task_struct *p, *old; 195 int index = 0; 196 197 e = bpf_map_lookup_elem(&kernel_percpu_array, &index); 198 if (!e) 199 return 0; 200 201 p = bpf_task_from_pid(1); 202 if (!p) 203 return 0; 204 205 old = bpf_kptr_xchg(&e->task, p); 206 if (old) 207 bpf_task_release(old); 208 return 0; 209 } 210 211 SEC("?fentry.s/bpf_fentry_test1") 212 __failure __msg("invalid kptr access, R2 type=ptr_ expected=ptr_val_t") 213 int BPF_PROG(reject_plain_alloc_into_percpu_kptr) 214 { 215 struct val_t __percpu_kptr *old; 216 struct val_t *p; 217 struct elem *e; 218 int index = 0; 219 220 e = bpf_map_lookup_elem(&array, &index); 221 if (!e) 222 return 0; 223 224 p = bpf_obj_new(struct val_t); 225 if (!p) 226 return 0; 227 228 old = bpf_kptr_xchg(&e->pc, p); 229 if (old) 230 bpf_percpu_obj_drop(old); 231 return 0; 232 } 233 234 SEC("?fentry.s/bpf_fentry_test1") 235 __failure __msg("bpf_percpu_obj_new type ID argument must be of a struct of scalars") 236 int BPF_PROG(test_array_map_6) 237 { 238 struct val_with_ptr_t __percpu_kptr *p; 239 240 p = bpf_percpu_obj_new(struct val_with_ptr_t); 241 if (!p) 242 return 0; 243 244 bpf_percpu_obj_drop(p); 245 return 0; 246 } 247 248 SEC("?fentry.s/bpf_fentry_test1") 249 __failure __msg("bpf_percpu_obj_new type ID argument must not contain special fields") 250 int BPF_PROG(test_array_map_7) 251 { 252 struct val_with_rb_root_t __percpu_kptr *p; 253 254 p = bpf_percpu_obj_new(struct val_with_rb_root_t); 255 if (!p) 256 return 0; 257 258 bpf_percpu_obj_drop(p); 259 return 0; 260 } 261 262 SEC("?fentry.s/bpf_fentry_test1") 263 __failure __msg("bpf_percpu_obj_new type size (600) is greater than 512") 264 int BPF_PROG(test_array_map_8) 265 { 266 struct val_600b_t __percpu_kptr *p; 267 268 p = bpf_percpu_obj_new(struct val_600b_t); 269 if (!p) 270 return 0; 271 272 bpf_percpu_obj_drop(p); 273 return 0; 274 } 275 276 char _license[] SEC("license") = "GPL"; 277