1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Example wrapper around BPF macros. |
4 | * |
5 | * Copyright (c) 2012 The Chromium OS Authors <chromium-os-dev@chromium.org> |
6 | * Author: Will Drewry <wad@chromium.org> |
7 | * |
8 | * The code may be used by anyone for any purpose, |
9 | * and can serve as a starting point for developing |
10 | * applications using prctl(PR_SET_SECCOMP, 2, ...). |
11 | * |
12 | * No guarantees are provided with respect to the correctness |
13 | * or functionality of this code. |
14 | */ |
15 | #ifndef __BPF_HELPER_H__ |
16 | #define __BPF_HELPER_H__ |
17 | |
18 | #include <asm/bitsperlong.h> /* for __BITS_PER_LONG */ |
19 | #include <endian.h> |
20 | #include <linux/filter.h> |
21 | #include <linux/seccomp.h> /* for seccomp_data */ |
22 | #include <linux/types.h> |
23 | #include <linux/unistd.h> |
24 | #include <stddef.h> |
25 | |
26 | #define BPF_LABELS_MAX 256 |
27 | struct bpf_labels { |
28 | int count; |
29 | struct __bpf_label { |
30 | const char *label; |
31 | __u32 location; |
32 | } labels[BPF_LABELS_MAX]; |
33 | }; |
34 | |
35 | int bpf_resolve_jumps(struct bpf_labels *labels, |
36 | struct sock_filter *filter, size_t count); |
37 | __u32 seccomp_bpf_label(struct bpf_labels *labels, const char *label); |
38 | void seccomp_bpf_print(struct sock_filter *filter, size_t count); |
39 | |
40 | #define JUMP_JT 0xff |
41 | #define JUMP_JF 0xff |
42 | #define LABEL_JT 0xfe |
43 | #define LABEL_JF 0xfe |
44 | |
45 | #define ALLOW \ |
46 | BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW) |
47 | #define DENY \ |
48 | BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_KILL) |
49 | #define JUMP(labels, label) \ |
50 | BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \ |
51 | JUMP_JT, JUMP_JF) |
52 | #define LABEL(labels, label) \ |
53 | BPF_JUMP(BPF_JMP+BPF_JA, FIND_LABEL((labels), (label)), \ |
54 | LABEL_JT, LABEL_JF) |
55 | #define SYSCALL(nr, jt) \ |
56 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (nr), 0, 1), \ |
57 | jt |
58 | |
59 | /* Lame, but just an example */ |
60 | #define FIND_LABEL(labels, label) seccomp_bpf_label((labels), #label) |
61 | |
62 | #define EXPAND(...) __VA_ARGS__ |
63 | |
64 | /* Ensure that we load the logically correct offset. */ |
65 | #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
66 | #define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) |
67 | #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
68 | #define LO_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32) |
69 | #else |
70 | #error "Unknown endianness" |
71 | #endif |
72 | |
73 | /* Map all width-sensitive operations */ |
74 | #if __BITS_PER_LONG == 32 |
75 | |
76 | #define JEQ(x, jt) JEQ32(x, EXPAND(jt)) |
77 | #define JNE(x, jt) JNE32(x, EXPAND(jt)) |
78 | #define JGT(x, jt) JGT32(x, EXPAND(jt)) |
79 | #define JLT(x, jt) JLT32(x, EXPAND(jt)) |
80 | #define JGE(x, jt) JGE32(x, EXPAND(jt)) |
81 | #define JLE(x, jt) JLE32(x, EXPAND(jt)) |
82 | #define JA(x, jt) JA32(x, EXPAND(jt)) |
83 | #define ARG(i) ARG_32(i) |
84 | |
85 | #elif __BITS_PER_LONG == 64 |
86 | |
87 | /* Ensure that we load the logically correct offset. */ |
88 | #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ |
89 | #define ENDIAN(_lo, _hi) _lo, _hi |
90 | #define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) + sizeof(__u32) |
91 | #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ |
92 | #define ENDIAN(_lo, _hi) _hi, _lo |
93 | #define HI_ARG(idx) offsetof(struct seccomp_data, args[(idx)]) |
94 | #endif |
95 | |
96 | union arg64 { |
97 | struct { |
98 | __u32 ENDIAN(lo32, hi32); |
99 | }; |
100 | __u64 u64; |
101 | }; |
102 | |
103 | #define JEQ(x, jt) \ |
104 | JEQ64(((union arg64){.u64 = (x)}).lo32, \ |
105 | ((union arg64){.u64 = (x)}).hi32, \ |
106 | EXPAND(jt)) |
107 | #define JGT(x, jt) \ |
108 | JGT64(((union arg64){.u64 = (x)}).lo32, \ |
109 | ((union arg64){.u64 = (x)}).hi32, \ |
110 | EXPAND(jt)) |
111 | #define JGE(x, jt) \ |
112 | JGE64(((union arg64){.u64 = (x)}).lo32, \ |
113 | ((union arg64){.u64 = (x)}).hi32, \ |
114 | EXPAND(jt)) |
115 | #define JNE(x, jt) \ |
116 | JNE64(((union arg64){.u64 = (x)}).lo32, \ |
117 | ((union arg64){.u64 = (x)}).hi32, \ |
118 | EXPAND(jt)) |
119 | #define JLT(x, jt) \ |
120 | JLT64(((union arg64){.u64 = (x)}).lo32, \ |
121 | ((union arg64){.u64 = (x)}).hi32, \ |
122 | EXPAND(jt)) |
123 | #define JLE(x, jt) \ |
124 | JLE64(((union arg64){.u64 = (x)}).lo32, \ |
125 | ((union arg64){.u64 = (x)}).hi32, \ |
126 | EXPAND(jt)) |
127 | |
128 | #define JA(x, jt) \ |
129 | JA64(((union arg64){.u64 = (x)}).lo32, \ |
130 | ((union arg64){.u64 = (x)}).hi32, \ |
131 | EXPAND(jt)) |
132 | #define ARG(i) ARG_64(i) |
133 | |
134 | #else |
135 | #error __BITS_PER_LONG value unusable. |
136 | #endif |
137 | |
138 | /* Loads the arg into A */ |
139 | #define ARG_32(idx) \ |
140 | BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx)) |
141 | |
142 | /* Loads lo into M[0] and hi into M[1] and A */ |
143 | #define ARG_64(idx) \ |
144 | BPF_STMT(BPF_LD+BPF_W+BPF_ABS, LO_ARG(idx)), \ |
145 | BPF_STMT(BPF_ST, 0), /* lo -> M[0] */ \ |
146 | BPF_STMT(BPF_LD+BPF_W+BPF_ABS, HI_ARG(idx)), \ |
147 | BPF_STMT(BPF_ST, 1) /* hi -> M[1] */ |
148 | |
149 | #define JEQ32(value, jt) \ |
150 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 0, 1), \ |
151 | jt |
152 | |
153 | #define JNE32(value, jt) \ |
154 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (value), 1, 0), \ |
155 | jt |
156 | |
157 | #define JA32(value, jt) \ |
158 | BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (value), 0, 1), \ |
159 | jt |
160 | |
161 | #define JGE32(value, jt) \ |
162 | BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 0, 1), \ |
163 | jt |
164 | |
165 | #define JGT32(value, jt) \ |
166 | BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 0, 1), \ |
167 | jt |
168 | |
169 | #define JLE32(value, jt) \ |
170 | BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (value), 1, 0), \ |
171 | jt |
172 | |
173 | #define JLT32(value, jt) \ |
174 | BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (value), 1, 0), \ |
175 | jt |
176 | |
177 | /* |
178 | * All the JXX64 checks assume lo is saved in M[0] and hi is saved in both |
179 | * A and M[1]. This invariant is kept by restoring A if necessary. |
180 | */ |
181 | #define JEQ64(lo, hi, jt) \ |
182 | /* if (hi != arg.hi) goto NOMATCH; */ \ |
183 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \ |
184 | BPF_STMT(BPF_LD+BPF_MEM, 0), /* swap in lo */ \ |
185 | /* if (lo != arg.lo) goto NOMATCH; */ \ |
186 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 0, 2), \ |
187 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
188 | jt, \ |
189 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
190 | |
191 | #define JNE64(lo, hi, jt) \ |
192 | /* if (hi != arg.hi) goto MATCH; */ \ |
193 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 3), \ |
194 | BPF_STMT(BPF_LD+BPF_MEM, 0), \ |
195 | /* if (lo != arg.lo) goto MATCH; */ \ |
196 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (lo), 2, 0), \ |
197 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
198 | jt, \ |
199 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
200 | |
201 | #define JA64(lo, hi, jt) \ |
202 | /* if (hi & arg.hi) goto MATCH; */ \ |
203 | BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (hi), 3, 0), \ |
204 | BPF_STMT(BPF_LD+BPF_MEM, 0), \ |
205 | /* if (lo & arg.lo) goto MATCH; */ \ |
206 | BPF_JUMP(BPF_JMP+BPF_JSET+BPF_K, (lo), 0, 2), \ |
207 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
208 | jt, \ |
209 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
210 | |
211 | #define JGE64(lo, hi, jt) \ |
212 | /* if (hi > arg.hi) goto MATCH; */ \ |
213 | BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \ |
214 | /* if (hi != arg.hi) goto NOMATCH; */ \ |
215 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \ |
216 | BPF_STMT(BPF_LD+BPF_MEM, 0), \ |
217 | /* if (lo >= arg.lo) goto MATCH; */ \ |
218 | BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 0, 2), \ |
219 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
220 | jt, \ |
221 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
222 | |
223 | #define JGT64(lo, hi, jt) \ |
224 | /* if (hi > arg.hi) goto MATCH; */ \ |
225 | BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (hi), 4, 0), \ |
226 | /* if (hi != arg.hi) goto NOMATCH; */ \ |
227 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \ |
228 | BPF_STMT(BPF_LD+BPF_MEM, 0), \ |
229 | /* if (lo > arg.lo) goto MATCH; */ \ |
230 | BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 0, 2), \ |
231 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
232 | jt, \ |
233 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
234 | |
235 | #define JLE64(lo, hi, jt) \ |
236 | /* if (hi < arg.hi) goto MATCH; */ \ |
237 | BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \ |
238 | /* if (hi != arg.hi) goto NOMATCH; */ \ |
239 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \ |
240 | BPF_STMT(BPF_LD+BPF_MEM, 0), \ |
241 | /* if (lo <= arg.lo) goto MATCH; */ \ |
242 | BPF_JUMP(BPF_JMP+BPF_JGT+BPF_K, (lo), 2, 0), \ |
243 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
244 | jt, \ |
245 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
246 | |
247 | #define JLT64(lo, hi, jt) \ |
248 | /* if (hi < arg.hi) goto MATCH; */ \ |
249 | BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (hi), 0, 4), \ |
250 | /* if (hi != arg.hi) goto NOMATCH; */ \ |
251 | BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, (hi), 0, 5), \ |
252 | BPF_STMT(BPF_LD+BPF_MEM, 0), \ |
253 | /* if (lo < arg.lo) goto MATCH; */ \ |
254 | BPF_JUMP(BPF_JMP+BPF_JGE+BPF_K, (lo), 2, 0), \ |
255 | BPF_STMT(BPF_LD+BPF_MEM, 1), \ |
256 | jt, \ |
257 | BPF_STMT(BPF_LD+BPF_MEM, 1) |
258 | |
259 | #define LOAD_SYSCALL_NR \ |
260 | BPF_STMT(BPF_LD+BPF_W+BPF_ABS, \ |
261 | offsetof(struct seccomp_data, nr)) |
262 | |
263 | #endif /* __BPF_HELPER_H__ */ |
264 | |