1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2020 Facebook */
3 #include <linux/btf.h>
4 #include <linux/btf_ids.h>
5 #include <linux/error-injection.h>
6 #include <linux/init.h>
7 #include <linux/module.h>
8 #include <linux/percpu-defs.h>
9 #include <linux/sysfs.h>
10 #include <linux/tracepoint.h>
11 #include "bpf_testmod.h"
12 
13 #define CREATE_TRACE_POINTS
14 #include "bpf_testmod-events.h"
15 
16 typedef int (*func_proto_typedef)(long);
17 typedef int (*func_proto_typedef_nested1)(func_proto_typedef);
18 typedef int (*func_proto_typedef_nested2)(func_proto_typedef_nested1);
19 
20 DEFINE_PER_CPU(int, bpf_testmod_ksym_percpu) = 123;
21 
22 noinline void
23 bpf_testmod_test_mod_kfunc(int i)
24 {
25 	*(int *)this_cpu_ptr(&bpf_testmod_ksym_percpu) = i;
26 }
27 
28 struct bpf_testmod_btf_type_tag_1 {
29 	int a;
30 };
31 
32 struct bpf_testmod_btf_type_tag_2 {
33 	struct bpf_testmod_btf_type_tag_1 __user *p;
34 };
35 
36 struct bpf_testmod_btf_type_tag_3 {
37 	struct bpf_testmod_btf_type_tag_1 __percpu *p;
38 };
39 
40 noinline int
41 bpf_testmod_test_btf_type_tag_user_1(struct bpf_testmod_btf_type_tag_1 __user *arg) {
42 	BTF_TYPE_EMIT(func_proto_typedef);
43 	BTF_TYPE_EMIT(func_proto_typedef_nested1);
44 	BTF_TYPE_EMIT(func_proto_typedef_nested2);
45 	return arg->a;
46 }
47 
48 noinline int
49 bpf_testmod_test_btf_type_tag_user_2(struct bpf_testmod_btf_type_tag_2 *arg) {
50 	return arg->p->a;
51 }
52 
53 noinline int
54 bpf_testmod_test_btf_type_tag_percpu_1(struct bpf_testmod_btf_type_tag_1 __percpu *arg) {
55 	return arg->a;
56 }
57 
58 noinline int
59 bpf_testmod_test_btf_type_tag_percpu_2(struct bpf_testmod_btf_type_tag_3 *arg) {
60 	return arg->p->a;
61 }
62 
63 noinline int bpf_testmod_loop_test(int n)
64 {
65 	int i, sum = 0;
66 
67 	/* the primary goal of this test is to test LBR. Create a lot of
68 	 * branches in the function, so we can catch it easily.
69 	 */
70 	for (i = 0; i < n; i++)
71 		sum += i;
72 	return sum;
73 }
74 
75 __weak noinline struct file *bpf_testmod_return_ptr(int arg)
76 {
77 	static struct file f = {};
78 
79 	switch (arg) {
80 	case 1: return (void *)EINVAL;		/* user addr */
81 	case 2: return (void *)0xcafe4a11;	/* user addr */
82 	case 3: return (void *)-EINVAL;		/* canonical, but invalid */
83 	case 4: return (void *)(1ull << 60);	/* non-canonical and invalid */
84 	case 5: return (void *)~(1ull << 30);	/* trigger extable */
85 	case 6: return &f;			/* valid addr */
86 	case 7: return (void *)((long)&f | 1);	/* kernel tricks */
87 	default: return NULL;
88 	}
89 }
90 
91 noinline ssize_t
92 bpf_testmod_test_read(struct file *file, struct kobject *kobj,
93 		      struct bin_attribute *bin_attr,
94 		      char *buf, loff_t off, size_t len)
95 {
96 	struct bpf_testmod_test_read_ctx ctx = {
97 		.buf = buf,
98 		.off = off,
99 		.len = len,
100 	};
101 	int i = 1;
102 
103 	while (bpf_testmod_return_ptr(i))
104 		i++;
105 
106 	/* This is always true. Use the check to make sure the compiler
107 	 * doesn't remove bpf_testmod_loop_test.
108 	 */
109 	if (bpf_testmod_loop_test(101) > 100)
110 		trace_bpf_testmod_test_read(current, &ctx);
111 
112 	/* Magic number to enable writable tp */
113 	if (len == 64) {
114 		struct bpf_testmod_test_writable_ctx writable = {
115 			.val = 1024,
116 		};
117 		trace_bpf_testmod_test_writable_bare(&writable);
118 		if (writable.early_ret)
119 			return snprintf(buf, len, "%d\n", writable.val);
120 	}
121 
122 	return -EIO; /* always fail */
123 }
124 EXPORT_SYMBOL(bpf_testmod_test_read);
125 ALLOW_ERROR_INJECTION(bpf_testmod_test_read, ERRNO);
126 
127 noinline ssize_t
128 bpf_testmod_test_write(struct file *file, struct kobject *kobj,
129 		      struct bin_attribute *bin_attr,
130 		      char *buf, loff_t off, size_t len)
131 {
132 	struct bpf_testmod_test_write_ctx ctx = {
133 		.buf = buf,
134 		.off = off,
135 		.len = len,
136 	};
137 
138 	trace_bpf_testmod_test_write_bare(current, &ctx);
139 
140 	return -EIO; /* always fail */
141 }
142 EXPORT_SYMBOL(bpf_testmod_test_write);
143 ALLOW_ERROR_INJECTION(bpf_testmod_test_write, ERRNO);
144 
145 static struct bin_attribute bin_attr_bpf_testmod_file __ro_after_init = {
146 	.attr = { .name = "bpf_testmod", .mode = 0666, },
147 	.read = bpf_testmod_test_read,
148 	.write = bpf_testmod_test_write,
149 };
150 
151 BTF_SET8_START(bpf_testmod_check_kfunc_ids)
152 BTF_ID_FLAGS(func, bpf_testmod_test_mod_kfunc)
153 BTF_SET8_END(bpf_testmod_check_kfunc_ids)
154 
155 static const struct btf_kfunc_id_set bpf_testmod_kfunc_set = {
156 	.owner = THIS_MODULE,
157 	.set   = &bpf_testmod_check_kfunc_ids,
158 };
159 
160 extern int bpf_fentry_test1(int a);
161 
162 static int bpf_testmod_init(void)
163 {
164 	int ret;
165 
166 	ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_SCHED_CLS, &bpf_testmod_kfunc_set);
167 	if (ret < 0)
168 		return ret;
169 	if (bpf_fentry_test1(0) < 0)
170 		return -EINVAL;
171 	return sysfs_create_bin_file(kernel_kobj, &bin_attr_bpf_testmod_file);
172 }
173 
174 static void bpf_testmod_exit(void)
175 {
176 	return sysfs_remove_bin_file(kernel_kobj, &bin_attr_bpf_testmod_file);
177 }
178 
179 module_init(bpf_testmod_init);
180 module_exit(bpf_testmod_exit);
181 
182 MODULE_AUTHOR("Andrii Nakryiko");
183 MODULE_DESCRIPTION("BPF selftests module");
184 MODULE_LICENSE("Dual BSD/GPL");
185