1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2021 Facebook */
3 #include <vmlinux.h>
4 #include <bpf/bpf_helpers.h>
5 #include "../bpf_testmod/bpf_testmod_kfunc.h"
6 
7 SEC("tc")
8 int kfunc_call_test4(struct __sk_buff *skb)
9 {
10 	struct bpf_sock *sk = skb->sk;
11 	long tmp;
12 
13 	if (!sk)
14 		return -1;
15 
16 	sk = bpf_sk_fullsock(sk);
17 	if (!sk)
18 		return -1;
19 
20 	tmp = bpf_kfunc_call_test4(-3, -30, -200, -1000);
21 	return (tmp >> 32) + tmp;
22 }
23 
24 SEC("tc")
25 int kfunc_call_test2(struct __sk_buff *skb)
26 {
27 	struct bpf_sock *sk = skb->sk;
28 
29 	if (!sk)
30 		return -1;
31 
32 	sk = bpf_sk_fullsock(sk);
33 	if (!sk)
34 		return -1;
35 
36 	return bpf_kfunc_call_test2((struct sock *)sk, 1, 2);
37 }
38 
39 SEC("tc")
40 int kfunc_call_test1(struct __sk_buff *skb)
41 {
42 	struct bpf_sock *sk = skb->sk;
43 	__u64 a = 1ULL << 32;
44 	__u32 ret;
45 
46 	if (!sk)
47 		return -1;
48 
49 	sk = bpf_sk_fullsock(sk);
50 	if (!sk)
51 		return -1;
52 
53 	a = bpf_kfunc_call_test1((struct sock *)sk, 1, a | 2, 3, a | 4);
54 	ret = a >> 32;   /* ret should be 2 */
55 	ret += (__u32)a; /* ret should be 12 */
56 
57 	return ret;
58 }
59 
60 SEC("tc")
61 int kfunc_call_test_ref_btf_id(struct __sk_buff *skb)
62 {
63 	struct prog_test_ref_kfunc *pt;
64 	unsigned long s = 0;
65 	int ret = 0;
66 
67 	pt = bpf_kfunc_call_test_acquire(&s);
68 	if (pt) {
69 		if (pt->a != 42 || pt->b != 108)
70 			ret = -1;
71 		bpf_kfunc_call_test_release(pt);
72 	}
73 	return ret;
74 }
75 
76 SEC("tc")
77 int kfunc_call_test_pass(struct __sk_buff *skb)
78 {
79 	struct prog_test_pass1 p1 = {};
80 	struct prog_test_pass2 p2 = {};
81 	short a = 0;
82 	__u64 b = 0;
83 	long c = 0;
84 	char d = 0;
85 	int e = 0;
86 
87 	bpf_kfunc_call_test_pass_ctx(skb);
88 	bpf_kfunc_call_test_pass1(&p1);
89 	bpf_kfunc_call_test_pass2(&p2);
90 
91 	bpf_kfunc_call_test_mem_len_pass1(&a, sizeof(a));
92 	bpf_kfunc_call_test_mem_len_pass1(&b, sizeof(b));
93 	bpf_kfunc_call_test_mem_len_pass1(&c, sizeof(c));
94 	bpf_kfunc_call_test_mem_len_pass1(&d, sizeof(d));
95 	bpf_kfunc_call_test_mem_len_pass1(&e, sizeof(e));
96 	bpf_kfunc_call_test_mem_len_fail2(&b, -1);
97 
98 	return 0;
99 }
100 
101 struct syscall_test_args {
102 	__u8 data[16];
103 	size_t size;
104 };
105 
106 SEC("syscall")
107 int kfunc_syscall_test(struct syscall_test_args *args)
108 {
109 	const long size = args->size;
110 
111 	if (size > sizeof(args->data))
112 		return -7; /* -E2BIG */
113 
114 	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(args->data));
115 	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(*args));
116 	bpf_kfunc_call_test_mem_len_pass1(&args->data, size);
117 
118 	return 0;
119 }
120 
121 SEC("syscall")
122 int kfunc_syscall_test_null(struct syscall_test_args *args)
123 {
124 	/* Must be called with args as a NULL pointer
125 	 * we do not check for it to have the verifier consider that
126 	 * the pointer might not be null, and so we can load it.
127 	 *
128 	 * So the following can not be added:
129 	 *
130 	 * if (args)
131 	 *      return -22;
132 	 */
133 
134 	bpf_kfunc_call_test_mem_len_pass1(args, 0);
135 
136 	return 0;
137 }
138 
139 SEC("tc")
140 int kfunc_call_test_get_mem(struct __sk_buff *skb)
141 {
142 	struct prog_test_ref_kfunc *pt;
143 	unsigned long s = 0;
144 	int *p = NULL;
145 	int ret = 0;
146 
147 	pt = bpf_kfunc_call_test_acquire(&s);
148 	if (pt) {
149 		p = bpf_kfunc_call_test_get_rdwr_mem(pt, 2 * sizeof(int));
150 		if (p) {
151 			p[0] = 42;
152 			ret = p[1]; /* 108 */
153 		} else {
154 			ret = -1;
155 		}
156 
157 		if (ret >= 0) {
158 			p = bpf_kfunc_call_test_get_rdonly_mem(pt, 2 * sizeof(int));
159 			if (p)
160 				ret = p[0]; /* 42 */
161 			else
162 				ret = -1;
163 		}
164 
165 		bpf_kfunc_call_test_release(pt);
166 	}
167 	return ret;
168 }
169 
170 SEC("tc")
171 int kfunc_call_test_static_unused_arg(struct __sk_buff *skb)
172 {
173 
174 	u32 expected = 5, actual;
175 
176 	actual = bpf_kfunc_call_test_static_unused_arg(expected, 0xdeadbeef);
177 	return actual != expected ? -1 : 0;
178 }
179 
180 char _license[] SEC("license") = "GPL";
181