| // SPDX-License-Identifier: GPL-2.0 | |
| #include <vmlinux.h> | |
| #include <bpf/bpf_tracing.h> | |
| #include <bpf/bpf_helpers.h> | |
| #include <bpf/bpf_core_read.h> | |
| #include "bpf_experimental.h" | |
| #include "linked_list.h" | |
| #define INIT \ | |
| struct map_value *v, *v2, *iv, *iv2; \ | |
| struct foo *f, *f1, *f2; \ | |
| struct bar *b; \ | |
| void *map; \ | |
| \ | |
| map = bpf_map_lookup_elem(&map_of_maps, &(int){ 0 }); \ | |
| if (!map) \ | |
| return 0; \ | |
| v = bpf_map_lookup_elem(&array_map, &(int){ 0 }); \ | |
| if (!v) \ | |
| return 0; \ | |
| v2 = bpf_map_lookup_elem(&array_map, &(int){ 0 }); \ | |
| if (!v2) \ | |
| return 0; \ | |
| iv = bpf_map_lookup_elem(map, &(int){ 0 }); \ | |
| if (!iv) \ | |
| return 0; \ | |
| iv2 = bpf_map_lookup_elem(map, &(int){ 0 }); \ | |
| if (!iv2) \ | |
| return 0; \ | |
| f = bpf_obj_new(typeof(*f)); \ | |
| if (!f) \ | |
| return 0; \ | |
| f1 = f; \ | |
| f2 = bpf_obj_new(typeof(*f2)); \ | |
| if (!f2) { \ | |
| bpf_obj_drop(f1); \ | |
| return 0; \ | |
| } \ | |
| b = bpf_obj_new(typeof(*b)); \ | |
| if (!b) { \ | |
| bpf_obj_drop(f2); \ | |
| bpf_obj_drop(f1); \ | |
| return 0; \ | |
| } | |
| #define CHECK(test, op, hexpr) \ | |
| SEC("?tc") \ | |
| int test##_missing_lock_##op(void *ctx) \ | |
| { \ | |
| INIT; \ | |
| void (*p)(void *) = (void *)&bpf_list_##op; \ | |
| p(hexpr); \ | |
| return 0; \ | |
| } | |
| CHECK(kptr, pop_front, &f->head); | |
| CHECK(kptr, pop_back, &f->head); | |
| CHECK(global, pop_front, &ghead); | |
| CHECK(global, pop_back, &ghead); | |
| CHECK(map, pop_front, &v->head); | |
| CHECK(map, pop_back, &v->head); | |
| CHECK(inner_map, pop_front, &iv->head); | |
| CHECK(inner_map, pop_back, &iv->head); | |
| #undef CHECK | |
| #define CHECK(test, op, hexpr, nexpr) \ | |
| SEC("?tc") \ | |
| int test##_missing_lock_##op(void *ctx) \ | |
| { \ | |
| INIT; \ | |
| bpf_list_##op(hexpr, nexpr); \ | |
| return 0; \ | |
| } | |
| CHECK(kptr, push_front, &f->head, &b->node); | |
| CHECK(kptr, push_back, &f->head, &b->node); | |
| CHECK(global, push_front, &ghead, &f->node2); | |
| CHECK(global, push_back, &ghead, &f->node2); | |
| CHECK(map, push_front, &v->head, &f->node2); | |
| CHECK(map, push_back, &v->head, &f->node2); | |
| CHECK(inner_map, push_front, &iv->head, &f->node2); | |
| CHECK(inner_map, push_back, &iv->head, &f->node2); | |
| #undef CHECK | |
| #define CHECK(test, op, lexpr, hexpr) \ | |
| SEC("?tc") \ | |
| int test##_incorrect_lock_##op(void *ctx) \ | |
| { \ | |
| INIT; \ | |
| void (*p)(void *) = (void *)&bpf_list_##op; \ | |
| bpf_spin_lock(lexpr); \ | |
| p(hexpr); \ | |
| return 0; \ | |
| } | |
| #define CHECK_OP(op) \ | |
| CHECK(kptr_kptr, op, &f1->lock, &f2->head); \ | |
| CHECK(kptr_global, op, &f1->lock, &ghead); \ | |
| CHECK(kptr_map, op, &f1->lock, &v->head); \ | |
| CHECK(kptr_inner_map, op, &f1->lock, &iv->head); \ | |
| \ | |
| CHECK(global_global, op, &glock2, &ghead); \ | |
| CHECK(global_kptr, op, &glock, &f1->head); \ | |
| CHECK(global_map, op, &glock, &v->head); \ | |
| CHECK(global_inner_map, op, &glock, &iv->head); \ | |
| \ | |
| CHECK(map_map, op, &v->lock, &v2->head); \ | |
| CHECK(map_kptr, op, &v->lock, &f2->head); \ | |
| CHECK(map_global, op, &v->lock, &ghead); \ | |
| CHECK(map_inner_map, op, &v->lock, &iv->head); \ | |
| \ | |
| CHECK(inner_map_inner_map, op, &iv->lock, &iv2->head); \ | |
| CHECK(inner_map_kptr, op, &iv->lock, &f2->head); \ | |
| CHECK(inner_map_global, op, &iv->lock, &ghead); \ | |
| CHECK(inner_map_map, op, &iv->lock, &v->head); | |
| CHECK_OP(pop_front); | |
| CHECK_OP(pop_back); | |
| #undef CHECK | |
| #undef CHECK_OP | |
| #define CHECK(test, op, lexpr, hexpr, nexpr) \ | |
| SEC("?tc") \ | |
| int test##_incorrect_lock_##op(void *ctx) \ | |
| { \ | |
| INIT; \ | |
| bpf_spin_lock(lexpr); \ | |
| bpf_list_##op(hexpr, nexpr); \ | |
| return 0; \ | |
| } | |
| #define CHECK_OP(op) \ | |
| CHECK(kptr_kptr, op, &f1->lock, &f2->head, &b->node); \ | |
| CHECK(kptr_global, op, &f1->lock, &ghead, &f->node2); \ | |
| CHECK(kptr_map, op, &f1->lock, &v->head, &f->node2); \ | |
| CHECK(kptr_inner_map, op, &f1->lock, &iv->head, &f->node2); \ | |
| \ | |
| CHECK(global_global, op, &glock2, &ghead, &f->node2); \ | |
| CHECK(global_kptr, op, &glock, &f1->head, &b->node); \ | |
| CHECK(global_map, op, &glock, &v->head, &f->node2); \ | |
| CHECK(global_inner_map, op, &glock, &iv->head, &f->node2); \ | |
| \ | |
| CHECK(map_map, op, &v->lock, &v2->head, &f->node2); \ | |
| CHECK(map_kptr, op, &v->lock, &f2->head, &b->node); \ | |
| CHECK(map_global, op, &v->lock, &ghead, &f->node2); \ | |
| CHECK(map_inner_map, op, &v->lock, &iv->head, &f->node2); \ | |
| \ | |
| CHECK(inner_map_inner_map, op, &iv->lock, &iv2->head, &f->node2);\ | |
| CHECK(inner_map_kptr, op, &iv->lock, &f2->head, &b->node); \ | |
| CHECK(inner_map_global, op, &iv->lock, &ghead, &f->node2); \ | |
| CHECK(inner_map_map, op, &iv->lock, &v->head, &f->node2); | |
| CHECK_OP(push_front); | |
| CHECK_OP(push_back); | |
| #undef CHECK | |
| #undef CHECK_OP | |
| #undef INIT | |
| struct obj_new_flex_elem { | |
| int lo; | |
| int hi; | |
| }; | |
| struct obj_new_flex { | |
| int hdr; | |
| struct obj_new_flex_elem cells[]; | |
| }; | |
| SEC("?kprobe/xyz") | |
| int map_compat_kprobe(void *ctx) | |
| { | |
| bpf_list_push_front(&ghead, NULL); | |
| return 0; | |
| } | |
| SEC("?kretprobe/xyz") | |
| int map_compat_kretprobe(void *ctx) | |
| { | |
| bpf_list_push_front(&ghead, NULL); | |
| return 0; | |
| } | |
| SEC("?tracepoint/xyz") | |
| int map_compat_tp(void *ctx) | |
| { | |
| bpf_list_push_front(&ghead, NULL); | |
| return 0; | |
| } | |
| SEC("?perf_event") | |
| int map_compat_perf(void *ctx) | |
| { | |
| bpf_list_push_front(&ghead, NULL); | |
| return 0; | |
| } | |
| SEC("?raw_tp/xyz") | |
| int map_compat_raw_tp(void *ctx) | |
| { | |
| bpf_list_push_front(&ghead, NULL); | |
| return 0; | |
| } | |
| SEC("?raw_tp.w/xyz") | |
| int map_compat_raw_tp_w(void *ctx) | |
| { | |
| bpf_list_push_front(&ghead, NULL); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int obj_type_id_oor(void *ctx) | |
| { | |
| bpf_obj_new_impl(~0UL, NULL); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int obj_new_no_composite(void *ctx) | |
| { | |
| bpf_obj_new_impl(bpf_core_type_id_local(int), (void *)42); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int obj_new_no_struct(void *ctx) | |
| { | |
| (void)bpf_obj_new(union { int data; unsigned udata; }); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int obj_new_flex_array(void *ctx) | |
| { | |
| struct obj_new_flex *p; | |
| p = bpf_obj_new_impl(bpf_core_type_id_local(struct obj_new_flex), NULL); | |
| if (!p) | |
| return 0; | |
| p->cells[0].hi = 42; | |
| bpf_obj_drop_impl(p, NULL); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int obj_drop_non_zero_off(void *ctx) | |
| { | |
| void *f; | |
| f = bpf_obj_new(struct foo); | |
| if (!f) | |
| return 0; | |
| bpf_obj_drop(f+1); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int new_null_ret(void *ctx) | |
| { | |
| return bpf_obj_new(struct foo)->data; | |
| } | |
| SEC("?tc") | |
| int obj_new_acq(void *ctx) | |
| { | |
| (void)bpf_obj_new(struct foo); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int use_after_drop(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_obj_drop(f); | |
| return f->data; | |
| } | |
| SEC("?tc") | |
| int ptr_walk_scalar(void *ctx) | |
| { | |
| struct test1 { | |
| struct test2 { | |
| struct test2 *next; | |
| } *ptr; | |
| } *p; | |
| p = bpf_obj_new(typeof(*p)); | |
| if (!p) | |
| return 0; | |
| bpf_this_cpu_ptr(p->ptr); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int direct_read_lock(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| return *(int *)&f->lock; | |
| } | |
| SEC("?tc") | |
| int direct_write_lock(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| *(int *)&f->lock = 0; | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int direct_read_head(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| return *(int *)&f->head; | |
| } | |
| SEC("?tc") | |
| int direct_write_head(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| *(int *)&f->head = 0; | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int direct_read_node(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| return *(int *)&f->node2; | |
| } | |
| SEC("?tc") | |
| int direct_write_node(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| *(int *)&f->node2 = 0; | |
| return 0; | |
| } | |
| static __always_inline | |
| int use_after_unlock(bool push_front) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| f->data = 42; | |
| if (push_front) | |
| bpf_list_push_front(&ghead, &f->node2); | |
| else | |
| bpf_list_push_back(&ghead, &f->node2); | |
| bpf_spin_unlock(&glock); | |
| return f->data; | |
| } | |
| SEC("?tc") | |
| int use_after_unlock_push_front(void *ctx) | |
| { | |
| return use_after_unlock(true); | |
| } | |
| SEC("?tc") | |
| int use_after_unlock_push_back(void *ctx) | |
| { | |
| return use_after_unlock(false); | |
| } | |
| static __always_inline | |
| int list_double_add(bool push_front) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| if (push_front) { | |
| bpf_list_push_front(&ghead, &f->node2); | |
| bpf_list_push_front(&ghead, &f->node2); | |
| } else { | |
| bpf_list_push_back(&ghead, &f->node2); | |
| bpf_list_push_back(&ghead, &f->node2); | |
| } | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int double_push_front(void *ctx) | |
| { | |
| return list_double_add(true); | |
| } | |
| SEC("?tc") | |
| int double_push_back(void *ctx) | |
| { | |
| return list_double_add(false); | |
| } | |
| SEC("?tc") | |
| int no_node_value_type(void *ctx) | |
| { | |
| void *p; | |
| p = bpf_obj_new(struct { int data; }); | |
| if (!p) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front(&ghead, p); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_value_type(void *ctx) | |
| { | |
| struct bar *b; | |
| b = bpf_obj_new(typeof(*b)); | |
| if (!b) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front(&ghead, &b->node); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_node_var_off(struct __sk_buff *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front(&ghead, (void *)&f->node2 + ctx->protocol); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_node_off1(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front(&ghead, (void *)&f->node2 + 1); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_node_off2(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front(&ghead, &f->node); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int no_head_type(void *ctx) | |
| { | |
| void *p; | |
| p = bpf_obj_new(typeof(struct { int data; })); | |
| if (!p) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front(p, NULL); | |
| bpf_spin_lock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_head_var_off1(struct __sk_buff *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front((void *)&ghead + ctx->protocol, &f->node2); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_head_var_off2(struct __sk_buff *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front((void *)&f->head + ctx->protocol, &f->node2); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_head_off1(void *ctx) | |
| { | |
| struct foo *f; | |
| struct bar *b; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| b = bpf_obj_new(typeof(*b)); | |
| if (!b) { | |
| bpf_obj_drop(f); | |
| return 0; | |
| } | |
| bpf_spin_lock(&f->lock); | |
| bpf_list_push_front((void *)&f->head + 1, &b->node); | |
| bpf_spin_unlock(&f->lock); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int incorrect_head_off2(void *ctx) | |
| { | |
| struct foo *f; | |
| f = bpf_obj_new(typeof(*f)); | |
| if (!f) | |
| return 0; | |
| bpf_spin_lock(&glock); | |
| bpf_list_push_front((void *)&ghead + 1, &f->node2); | |
| bpf_spin_unlock(&glock); | |
| return 0; | |
| } | |
| static __always_inline | |
| int pop_ptr_off(void *(*op)(void *head)) | |
| { | |
| struct { | |
| struct bpf_list_head head __contains(foo, node2); | |
| struct bpf_spin_lock lock; | |
| } *p; | |
| struct bpf_list_node *n; | |
| p = bpf_obj_new(typeof(*p)); | |
| if (!p) | |
| return 0; | |
| bpf_spin_lock(&p->lock); | |
| n = op(&p->head); | |
| bpf_spin_unlock(&p->lock); | |
| if (!n) | |
| return 0; | |
| bpf_spin_lock((void *)n); | |
| return 0; | |
| } | |
| SEC("?tc") | |
| int pop_front_off(void *ctx) | |
| { | |
| return pop_ptr_off((void *)bpf_list_pop_front); | |
| } | |
| SEC("?tc") | |
| int pop_back_off(void *ctx) | |
| { | |
| return pop_ptr_off((void *)bpf_list_pop_back); | |
| } | |
| char _license[] SEC("license") = "GPL"; |