filter.h 20.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * Linux Socket Filter Data Structures
 */
#ifndef __LINUX_FILTER_H__
#define __LINUX_FILTER_H__

7 8
#include <stdarg.h>

A
Arun Sharma 已提交
9
#include <linux/atomic.h>
10
#include <linux/compat.h>
11
#include <linux/skbuff.h>
12 13
#include <linux/linkage.h>
#include <linux/printk.h>
14
#include <linux/workqueue.h>
15
#include <linux/sched.h>
16
#include <linux/capability.h>
17
#include <linux/cryptohash.h>
18

19
#include <net/sch_generic.h>
20

21
#include <asm/cacheflush.h>
22 23

#include <uapi/linux/filter.h>
24
#include <uapi/linux/bpf.h>
25 26 27 28

struct sk_buff;
struct sock;
struct seccomp_data;
29
struct bpf_prog_aux;
30

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
/* ArgX, context and stack frame pointer register positions. Note,
 * Arg1, Arg2, Arg3, etc are used as argument mappings of function
 * calls in BPF_CALL instruction.
 */
#define BPF_REG_ARG1	BPF_REG_1
#define BPF_REG_ARG2	BPF_REG_2
#define BPF_REG_ARG3	BPF_REG_3
#define BPF_REG_ARG4	BPF_REG_4
#define BPF_REG_ARG5	BPF_REG_5
#define BPF_REG_CTX	BPF_REG_6
#define BPF_REG_FP	BPF_REG_10

/* Additional register mappings for converted user programs. */
#define BPF_REG_A	BPF_REG_0
#define BPF_REG_X	BPF_REG_7
#define BPF_REG_TMP	BPF_REG_8
47

48 49 50 51 52 53 54 55 56
/* Kernel hidden auxiliary/helper register for hardening step.
 * Only used by eBPF JITs. It's nothing more than a temporary
 * register that JITs use internally, only that here it's part
 * of eBPF instructions that have been rewritten for blinding
 * constants. See JIT pre-step in bpf_jit_blind_constants().
 */
#define BPF_REG_AX		MAX_BPF_REG
#define MAX_BPF_JIT_REG		(MAX_BPF_REG + 1)

57 58 59
/* BPF program can access up to 512 bytes of stack space. */
#define MAX_BPF_STACK	512

60 61 62
/* Maximum BPF program size in bytes. */
#define MAX_BPF_SIZE	(BPF_MAXINSNS * sizeof(struct bpf_insn))

63 64
/* Helper macros for filter block array initializers. */

65
/* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */
66

67
#define BPF_ALU64_REG(OP, DST, SRC)				\
68
	((struct bpf_insn) {					\
69
		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_X,	\
70 71
		.dst_reg = DST,					\
		.src_reg = SRC,					\
72 73 74
		.off   = 0,					\
		.imm   = 0 })

75
#define BPF_ALU32_REG(OP, DST, SRC)				\
76
	((struct bpf_insn) {					\
77
		.code  = BPF_ALU | BPF_OP(OP) | BPF_X,		\
78 79
		.dst_reg = DST,					\
		.src_reg = SRC,					\
80 81 82
		.off   = 0,					\
		.imm   = 0 })

83
/* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */
84

85
#define BPF_ALU64_IMM(OP, DST, IMM)				\
86
	((struct bpf_insn) {					\
87
		.code  = BPF_ALU64 | BPF_OP(OP) | BPF_K,	\
88 89
		.dst_reg = DST,					\
		.src_reg = 0,					\
90 91 92
		.off   = 0,					\
		.imm   = IMM })

93
#define BPF_ALU32_IMM(OP, DST, IMM)				\
94
	((struct bpf_insn) {					\
95
		.code  = BPF_ALU | BPF_OP(OP) | BPF_K,		\
96 97
		.dst_reg = DST,					\
		.src_reg = 0,					\
98 99 100 101 102
		.off   = 0,					\
		.imm   = IMM })

/* Endianess conversion, cpu_to_{l,b}e(), {l,b}e_to_cpu() */

103
#define BPF_ENDIAN(TYPE, DST, LEN)				\
104
	((struct bpf_insn) {					\
105
		.code  = BPF_ALU | BPF_END | BPF_SRC(TYPE),	\
106 107
		.dst_reg = DST,					\
		.src_reg = 0,					\
108 109 110
		.off   = 0,					\
		.imm   = LEN })

111
/* Short form of mov, dst_reg = src_reg */
112

113
#define BPF_MOV64_REG(DST, SRC)					\
114
	((struct bpf_insn) {					\
115
		.code  = BPF_ALU64 | BPF_MOV | BPF_X,		\
116 117
		.dst_reg = DST,					\
		.src_reg = SRC,					\
118 119 120
		.off   = 0,					\
		.imm   = 0 })

121
#define BPF_MOV32_REG(DST, SRC)					\
122
	((struct bpf_insn) {					\
123
		.code  = BPF_ALU | BPF_MOV | BPF_X,		\
124 125
		.dst_reg = DST,					\
		.src_reg = SRC,					\
126 127 128
		.off   = 0,					\
		.imm   = 0 })

129
/* Short form of mov, dst_reg = imm32 */
130

131
#define BPF_MOV64_IMM(DST, IMM)					\
132
	((struct bpf_insn) {					\
133
		.code  = BPF_ALU64 | BPF_MOV | BPF_K,		\
134 135
		.dst_reg = DST,					\
		.src_reg = 0,					\
136 137 138
		.off   = 0,					\
		.imm   = IMM })

139
#define BPF_MOV32_IMM(DST, IMM)					\
140
	((struct bpf_insn) {					\
141
		.code  = BPF_ALU | BPF_MOV | BPF_K,		\
142 143
		.dst_reg = DST,					\
		.src_reg = 0,					\
144 145 146
		.off   = 0,					\
		.imm   = IMM })

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
/* BPF_LD_IMM64 macro encodes single 'load 64-bit immediate' insn */
#define BPF_LD_IMM64(DST, IMM)					\
	BPF_LD_IMM64_RAW(DST, 0, IMM)

#define BPF_LD_IMM64_RAW(DST, SRC, IMM)				\
	((struct bpf_insn) {					\
		.code  = BPF_LD | BPF_DW | BPF_IMM,		\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = 0,					\
		.imm   = (__u32) (IMM) }),			\
	((struct bpf_insn) {					\
		.code  = 0, /* zero is reserved opcode */	\
		.dst_reg = 0,					\
		.src_reg = 0,					\
		.off   = 0,					\
		.imm   = ((__u64) (IMM)) >> 32 })

165 166 167 168
/* pseudo BPF_LD_IMM64 insn used to refer to process-local map_fd */
#define BPF_LD_MAP_FD(DST, MAP_FD)				\
	BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)

169
/* Short form of mov based on type, BPF_X: dst_reg = src_reg, BPF_K: dst_reg = imm32 */
170

171
#define BPF_MOV64_RAW(TYPE, DST, SRC, IMM)			\
172
	((struct bpf_insn) {					\
173
		.code  = BPF_ALU64 | BPF_MOV | BPF_SRC(TYPE),	\
174 175
		.dst_reg = DST,					\
		.src_reg = SRC,					\
176 177 178
		.off   = 0,					\
		.imm   = IMM })

179
#define BPF_MOV32_RAW(TYPE, DST, SRC, IMM)			\
180
	((struct bpf_insn) {					\
181
		.code  = BPF_ALU | BPF_MOV | BPF_SRC(TYPE),	\
182 183
		.dst_reg = DST,					\
		.src_reg = SRC,					\
184 185 186
		.off   = 0,					\
		.imm   = IMM })

187
/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */
188

189
#define BPF_LD_ABS(SIZE, IMM)					\
190
	((struct bpf_insn) {					\
191
		.code  = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS,	\
192 193
		.dst_reg = 0,					\
		.src_reg = 0,					\
194
		.off   = 0,					\
195
		.imm   = IMM })
196

197
/* Indirect packet access, R0 = *(uint *) (skb->data + src_reg + imm32) */
198

199
#define BPF_LD_IND(SIZE, SRC, IMM)				\
200
	((struct bpf_insn) {					\
201
		.code  = BPF_LD | BPF_SIZE(SIZE) | BPF_IND,	\
202 203
		.dst_reg = 0,					\
		.src_reg = SRC,					\
204
		.off   = 0,					\
205
		.imm   = IMM })
206

207
/* Memory load, dst_reg = *(uint *) (src_reg + off16) */
208

209
#define BPF_LDX_MEM(SIZE, DST, SRC, OFF)			\
210
	((struct bpf_insn) {					\
211
		.code  = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM,	\
212 213
		.dst_reg = DST,					\
		.src_reg = SRC,					\
214 215 216
		.off   = OFF,					\
		.imm   = 0 })

217 218 219
/* Memory store, *(uint *) (dst_reg + off16) = src_reg */

#define BPF_STX_MEM(SIZE, DST, SRC, OFF)			\
220
	((struct bpf_insn) {					\
221
		.code  = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM,	\
222 223
		.dst_reg = DST,					\
		.src_reg = SRC,					\
224 225 226
		.off   = OFF,					\
		.imm   = 0 })

227 228 229 230 231 232 233 234 235 236
/* Atomic memory add, *(uint *)(dst_reg + off16) += src_reg */

#define BPF_STX_XADD(SIZE, DST, SRC, OFF)			\
	((struct bpf_insn) {					\
		.code  = BPF_STX | BPF_SIZE(SIZE) | BPF_XADD,	\
		.dst_reg = DST,					\
		.src_reg = SRC,					\
		.off   = OFF,					\
		.imm   = 0 })

237 238 239
/* Memory store, *(uint *) (dst_reg + off16) = imm32 */

#define BPF_ST_MEM(SIZE, DST, OFF, IMM)				\
240
	((struct bpf_insn) {					\
241 242 243 244 245 246 247
		.code  = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM,	\
		.dst_reg = DST,					\
		.src_reg = 0,					\
		.off   = OFF,					\
		.imm   = IMM })

/* Conditional jumps against registers, if (dst_reg 'op' src_reg) goto pc + off16 */
248

249
#define BPF_JMP_REG(OP, DST, SRC, OFF)				\
250
	((struct bpf_insn) {					\
251
		.code  = BPF_JMP | BPF_OP(OP) | BPF_X,		\
252 253
		.dst_reg = DST,					\
		.src_reg = SRC,					\
254 255 256
		.off   = OFF,					\
		.imm   = 0 })

257
/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */
258

259
#define BPF_JMP_IMM(OP, DST, IMM, OFF)				\
260
	((struct bpf_insn) {					\
261
		.code  = BPF_JMP | BPF_OP(OP) | BPF_K,		\
262 263
		.dst_reg = DST,					\
		.src_reg = 0,					\
264 265 266 267 268 269
		.off   = OFF,					\
		.imm   = IMM })

/* Function call */

#define BPF_EMIT_CALL(FUNC)					\
270
	((struct bpf_insn) {					\
271
		.code  = BPF_JMP | BPF_CALL,			\
272 273
		.dst_reg = 0,					\
		.src_reg = 0,					\
274 275 276 277 278
		.off   = 0,					\
		.imm   = ((FUNC) - __bpf_call_base) })

/* Raw code statement block */

279
#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)			\
280
	((struct bpf_insn) {					\
281
		.code  = CODE,					\
282 283
		.dst_reg = DST,					\
		.src_reg = SRC,					\
284 285 286 287 288 289
		.off   = OFF,					\
		.imm   = IMM })

/* Program exit */

#define BPF_EXIT_INSN()						\
290
	((struct bpf_insn) {					\
291
		.code  = BPF_JMP | BPF_EXIT,			\
292 293
		.dst_reg = 0,					\
		.src_reg = 0,					\
294 295 296
		.off   = 0,					\
		.imm   = 0 })

297 298 299 300 301 302 303 304
/* Internal classic blocks for direct assignment */

#define __BPF_STMT(CODE, K)					\
	((struct sock_filter) BPF_STMT(CODE, K))

#define __BPF_JUMP(CODE, K, JT, JF)				\
	((struct sock_filter) BPF_JUMP(CODE, K, JT, JF))

305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
#define bytes_to_bpf_size(bytes)				\
({								\
	int bpf_size = -EINVAL;					\
								\
	if (bytes == sizeof(u8))				\
		bpf_size = BPF_B;				\
	else if (bytes == sizeof(u16))				\
		bpf_size = BPF_H;				\
	else if (bytes == sizeof(u32))				\
		bpf_size = BPF_W;				\
	else if (bytes == sizeof(u64))				\
		bpf_size = BPF_DW;				\
								\
	bpf_size;						\
})
320

321 322 323 324 325 326 327 328 329 330 331 332 333 334
#define BPF_SIZEOF(type)					\
	({							\
		const int __size = bytes_to_bpf_size(sizeof(type)); \
		BUILD_BUG_ON(__size < 0);			\
		__size;						\
	})

#define BPF_FIELD_SIZEOF(type, field)				\
	({							\
		const int __size = bytes_to_bpf_size(FIELD_SIZEOF(type, field)); \
		BUILD_BUG_ON(__size < 0);			\
		__size;						\
	})

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
#define __BPF_MAP_0(m, v, ...) v
#define __BPF_MAP_1(m, v, t, a, ...) m(t, a)
#define __BPF_MAP_2(m, v, t, a, ...) m(t, a), __BPF_MAP_1(m, v, __VA_ARGS__)
#define __BPF_MAP_3(m, v, t, a, ...) m(t, a), __BPF_MAP_2(m, v, __VA_ARGS__)
#define __BPF_MAP_4(m, v, t, a, ...) m(t, a), __BPF_MAP_3(m, v, __VA_ARGS__)
#define __BPF_MAP_5(m, v, t, a, ...) m(t, a), __BPF_MAP_4(m, v, __VA_ARGS__)

#define __BPF_REG_0(...) __BPF_PAD(5)
#define __BPF_REG_1(...) __BPF_MAP(1, __VA_ARGS__), __BPF_PAD(4)
#define __BPF_REG_2(...) __BPF_MAP(2, __VA_ARGS__), __BPF_PAD(3)
#define __BPF_REG_3(...) __BPF_MAP(3, __VA_ARGS__), __BPF_PAD(2)
#define __BPF_REG_4(...) __BPF_MAP(4, __VA_ARGS__), __BPF_PAD(1)
#define __BPF_REG_5(...) __BPF_MAP(5, __VA_ARGS__)

#define __BPF_MAP(n, ...) __BPF_MAP_##n(__VA_ARGS__)
#define __BPF_REG(n, ...) __BPF_REG_##n(__VA_ARGS__)

#define __BPF_CAST(t, a)						       \
	(__force t)							       \
	(__force							       \
	 typeof(__builtin_choose_expr(sizeof(t) == sizeof(unsigned long),      \
				      (unsigned long)0, (t)0))) a
#define __BPF_V void
#define __BPF_N

#define __BPF_DECL_ARGS(t, a) t   a
#define __BPF_DECL_REGS(t, a) u64 a

#define __BPF_PAD(n)							       \
	__BPF_MAP(n, __BPF_DECL_ARGS, __BPF_N, u64, __ur_1, u64, __ur_2,       \
		  u64, __ur_3, u64, __ur_4, u64, __ur_5)

#define BPF_CALL_x(x, name, ...)					       \
	static __always_inline						       \
	u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__));   \
	u64 name(__BPF_REG(x, __BPF_DECL_REGS, __BPF_N, __VA_ARGS__));	       \
	u64 name(__BPF_REG(x, __BPF_DECL_REGS, __BPF_N, __VA_ARGS__))	       \
	{								       \
		return ____##name(__BPF_MAP(x,__BPF_CAST,__BPF_N,__VA_ARGS__));\
	}								       \
	static __always_inline						       \
	u64 ____##name(__BPF_MAP(x, __BPF_DECL_ARGS, __BPF_V, __VA_ARGS__))

#define BPF_CALL_0(name, ...)	BPF_CALL_x(0, name, __VA_ARGS__)
#define BPF_CALL_1(name, ...)	BPF_CALL_x(1, name, __VA_ARGS__)
#define BPF_CALL_2(name, ...)	BPF_CALL_x(2, name, __VA_ARGS__)
#define BPF_CALL_3(name, ...)	BPF_CALL_x(3, name, __VA_ARGS__)
#define BPF_CALL_4(name, ...)	BPF_CALL_x(4, name, __VA_ARGS__)
#define BPF_CALL_5(name, ...)	BPF_CALL_x(5, name, __VA_ARGS__)

385 386
#ifdef CONFIG_COMPAT
/* A struct sock_filter is architecture independent. */
387 388
struct compat_sock_fprog {
	u16		len;
389
	compat_uptr_t	filter;	/* struct sock_filter * */
390 391 392
};
#endif

393 394 395 396 397
struct sock_fprog_kern {
	u16			len;
	struct sock_filter	*filter;
};

398 399 400 401 402
struct bpf_binary_header {
	unsigned int pages;
	u8 image[];
};

403
struct bpf_prog {
404
	u16			pages;		/* Number of allocated pages */
405 406
	kmemcheck_bitfield_begin(meta);
	u16			jited:1,	/* Is our filter JIT'ed? */
407
				gpl_compatible:1, /* Is filter GPL compatible? */
408
				cb_access:1,	/* Is control block accessed? */
409
				dst_needed:1;	/* Do we need dst entry? */
410
	kmemcheck_bitfield_end(meta);
411
	enum bpf_prog_type	type;		/* Type of BPF program */
412 413
	u32			len;		/* Number of filter blocks */
	u32			digest[SHA_DIGEST_WORDS]; /* Program digest */
414
	struct bpf_prog_aux	*aux;		/* Auxiliary fields */
415
	struct sock_fprog_kern	*orig_prog;	/* Original BPF program */
416 417
	unsigned int		(*bpf_func)(const void *ctx,
					    const struct bpf_insn *insn);
418
	/* Instructions for interpreter */
419
	union {
420
		struct sock_filter	insns[0];
421
		struct bpf_insn		insnsi[0];
422
	};
423 424
};

425 426 427 428 429 430 431 432
struct sk_filter {
	atomic_t	refcnt;
	struct rcu_head	rcu;
	struct bpf_prog	*prog;
};

#define BPF_PROG_RUN(filter, ctx)  (*filter->bpf_func)(ctx, filter->insnsi)

433 434
#define BPF_SKB_CB_LEN QDISC_CB_PRIV_LEN

435 436 437 438 439
struct bpf_skb_data_end {
	struct qdisc_skb_cb qdisc_cb;
	void *data_end;
};

440 441 442 443 444
struct xdp_buff {
	void *data;
	void *data_end;
};

445
/* compute the linear packet data range [data, data_end) which
446
 * will be accessed by cls_bpf, act_bpf and lwt programs
447 448 449 450 451 452 453 454 455
 */
static inline void bpf_compute_data_end(struct sk_buff *skb)
{
	struct bpf_skb_data_end *cb = (struct bpf_skb_data_end *)skb->cb;

	BUILD_BUG_ON(sizeof(*cb) > FIELD_SIZEOF(struct sk_buff, cb));
	cb->data_end = skb->data + skb_headlen(skb);
}

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
static inline u8 *bpf_skb_cb(struct sk_buff *skb)
{
	/* eBPF programs may read/write skb->cb[] area to transfer meta
	 * data between tail calls. Since this also needs to work with
	 * tc, that scratch memory is mapped to qdisc_skb_cb's data area.
	 *
	 * In some socket filter cases, the cb unfortunately needs to be
	 * saved/restored so that protocol specific skb->cb[] data won't
	 * be lost. In any case, due to unpriviledged eBPF programs
	 * attached to sockets, we need to clear the bpf_skb_cb() area
	 * to not leak previous contents to user space.
	 */
	BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) != BPF_SKB_CB_LEN);
	BUILD_BUG_ON(FIELD_SIZEOF(struct __sk_buff, cb) !=
		     FIELD_SIZEOF(struct qdisc_skb_cb, data));

	return qdisc_skb_cb(skb)->data;
}

475 476 477
static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog,
				       struct sk_buff *skb)
{
478 479
	u8 *cb_data = bpf_skb_cb(skb);
	u8 cb_saved[BPF_SKB_CB_LEN];
480 481 482
	u32 res;

	if (unlikely(prog->cb_access)) {
483 484
		memcpy(cb_saved, cb_data, sizeof(cb_saved));
		memset(cb_data, 0, sizeof(cb_saved));
485 486 487 488 489
	}

	res = BPF_PROG_RUN(prog, skb);

	if (unlikely(prog->cb_access))
490
		memcpy(cb_data, cb_saved, sizeof(cb_saved));
491 492 493 494 495 496 497

	return res;
}

static inline u32 bpf_prog_run_clear_cb(const struct bpf_prog *prog,
					struct sk_buff *skb)
{
498
	u8 *cb_data = bpf_skb_cb(skb);
499 500

	if (unlikely(prog->cb_access))
501 502
		memset(cb_data, 0, BPF_SKB_CB_LEN);

503 504 505
	return BPF_PROG_RUN(prog, skb);
}

506 507
static __always_inline u32 bpf_prog_run_xdp(const struct bpf_prog *prog,
					    struct xdp_buff *xdp)
508
{
509 510 511 512 513 514 515
	/* Caller needs to hold rcu_read_lock() (!), otherwise program
	 * can be released while still running, or map elements could be
	 * freed early while still having concurrent users. XDP fastpath
	 * already takes rcu_read_lock() when fetching the program, so
	 * it's not necessary here anymore.
	 */
	return BPF_PROG_RUN(prog, xdp);
516 517
}

518
static inline unsigned int bpf_prog_size(unsigned int proglen)
519
{
520 521
	return max(sizeof(struct bpf_prog),
		   offsetof(struct bpf_prog, insns[proglen]));
522 523
}

524 525 526 527 528 529 530 531 532 533
static inline bool bpf_prog_was_classic(const struct bpf_prog *prog)
{
	/* When classic BPF programs have been loaded and the arch
	 * does not have a classic BPF JIT (anymore), they have been
	 * converted via bpf_migrate_filter() to eBPF and thus always
	 * have an unspec program type.
	 */
	return prog->type == BPF_PROG_TYPE_UNSPEC;
}

534
#define bpf_classic_proglen(fprog) (fprog->len * sizeof(fprog->filter[0]))
535

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
#ifdef CONFIG_DEBUG_SET_MODULE_RONX
static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
{
	set_memory_ro((unsigned long)fp, fp->pages);
}

static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
{
	set_memory_rw((unsigned long)fp, fp->pages);
}
#else
static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
{
}

static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
{
}
#endif /* CONFIG_DEBUG_SET_MODULE_RONX */

556 557 558 559 560
int sk_filter_trim_cap(struct sock *sk, struct sk_buff *skb, unsigned int cap);
static inline int sk_filter(struct sock *sk, struct sk_buff *skb)
{
	return sk_filter_trim_cap(sk, skb, 1);
}
561

562
struct bpf_prog *bpf_prog_select_runtime(struct bpf_prog *fp, int *err);
563
void bpf_prog_free(struct bpf_prog *fp);
564

565 566 567 568 569 570 571 572 573 574 575
struct bpf_prog *bpf_prog_alloc(unsigned int size, gfp_t gfp_extra_flags);
struct bpf_prog *bpf_prog_realloc(struct bpf_prog *fp_old, unsigned int size,
				  gfp_t gfp_extra_flags);
void __bpf_prog_free(struct bpf_prog *fp);

static inline void bpf_prog_unlock_free(struct bpf_prog *fp)
{
	bpf_prog_unlock_ro(fp);
	__bpf_prog_free(fp);
}

576 577 578
typedef int (*bpf_aux_classic_check_t)(struct sock_filter *filter,
				       unsigned int flen);

579
int bpf_prog_create(struct bpf_prog **pfp, struct sock_fprog_kern *fprog);
580
int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog,
581
			      bpf_aux_classic_check_t trans, bool save_orig);
582
void bpf_prog_destroy(struct bpf_prog *fp);
583

584
int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
585
int sk_attach_bpf(u32 ufd, struct sock *sk);
586 587
int sk_reuseport_attach_filter(struct sock_fprog *fprog, struct sock *sk);
int sk_reuseport_attach_bpf(u32 ufd, struct sock *sk);
588 589 590 591
int sk_detach_filter(struct sock *sk);
int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
		  unsigned int len);

592
bool sk_filter_charge(struct sock *sk, struct sk_filter *fp);
593
void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp);
594

595
u64 __bpf_call_base(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
596 597

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog);
598
bool bpf_helper_changes_skb_data(void *func);
599

600 601
struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
				       const struct bpf_insn *patch, u32 len);
602
void bpf_warn_invalid_xdp_action(u32 act);
603

604
#ifdef CONFIG_BPF_JIT
605
extern int bpf_jit_enable;
606
extern int bpf_jit_harden;
607

608 609 610 611 612 613 614 615 616 617 618
typedef void (*bpf_jit_fill_hole_t)(void *area, unsigned int size);

struct bpf_binary_header *
bpf_jit_binary_alloc(unsigned int proglen, u8 **image_ptr,
		     unsigned int alignment,
		     bpf_jit_fill_hole_t bpf_fill_ill_insns);
void bpf_jit_binary_free(struct bpf_binary_header *hdr);

void bpf_jit_compile(struct bpf_prog *fp);
void bpf_jit_free(struct bpf_prog *fp);

619 620 621
struct bpf_prog *bpf_jit_blind_constants(struct bpf_prog *fp);
void bpf_jit_prog_release_other(struct bpf_prog *fp, struct bpf_prog *fp_other);

622 623 624
static inline void bpf_jit_dump(unsigned int flen, unsigned int proglen,
				u32 pass, void *image)
{
625 626 627
	pr_err("flen=%u proglen=%u pass=%u image=%pK from=%s pid=%d\n", flen,
	       proglen, pass, image, current->comm, task_pid_nr(current));

628 629 630 631
	if (image)
		print_hex_dump(KERN_ERR, "JIT code: ", DUMP_PREFIX_OFFSET,
			       16, 1, image, proglen, false);
}
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658

static inline bool bpf_jit_is_ebpf(void)
{
# ifdef CONFIG_HAVE_EBPF_JIT
	return true;
# else
	return false;
# endif
}

static inline bool bpf_jit_blinding_enabled(void)
{
	/* These are the prerequisites, should someone ever have the
	 * idea to call blinding outside of them, we make sure to
	 * bail out.
	 */
	if (!bpf_jit_is_ebpf())
		return false;
	if (!bpf_jit_enable)
		return false;
	if (!bpf_jit_harden)
		return false;
	if (bpf_jit_harden == 1 && capable(CAP_SYS_ADMIN))
		return false;

	return true;
}
659 660 661 662 663 664 665 666 667 668 669
#else
static inline void bpf_jit_compile(struct bpf_prog *fp)
{
}

static inline void bpf_jit_free(struct bpf_prog *fp)
{
	bpf_prog_unlock_free(fp);
}
#endif /* CONFIG_BPF_JIT */

670 671
#define BPF_ANC		BIT(15)

672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
static inline bool bpf_needs_clear_a(const struct sock_filter *first)
{
	switch (first->code) {
	case BPF_RET | BPF_K:
	case BPF_LD | BPF_W | BPF_LEN:
		return false;

	case BPF_LD | BPF_W | BPF_ABS:
	case BPF_LD | BPF_H | BPF_ABS:
	case BPF_LD | BPF_B | BPF_ABS:
		if (first->k == SKF_AD_OFF + SKF_AD_ALU_XOR_X)
			return true;
		return false;

	default:
		return true;
	}
}

691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
static inline u16 bpf_anc_helper(const struct sock_filter *ftest)
{
	BUG_ON(ftest->code & BPF_ANC);

	switch (ftest->code) {
	case BPF_LD | BPF_W | BPF_ABS:
	case BPF_LD | BPF_H | BPF_ABS:
	case BPF_LD | BPF_B | BPF_ABS:
#define BPF_ANCILLARY(CODE)	case SKF_AD_OFF + SKF_AD_##CODE:	\
				return BPF_ANC | SKF_AD_##CODE
		switch (ftest->k) {
		BPF_ANCILLARY(PROTOCOL);
		BPF_ANCILLARY(PKTTYPE);
		BPF_ANCILLARY(IFINDEX);
		BPF_ANCILLARY(NLATTR);
		BPF_ANCILLARY(NLATTR_NEST);
		BPF_ANCILLARY(MARK);
		BPF_ANCILLARY(QUEUE);
		BPF_ANCILLARY(HATYPE);
		BPF_ANCILLARY(RXHASH);
		BPF_ANCILLARY(CPU);
		BPF_ANCILLARY(ALU_XOR_X);
		BPF_ANCILLARY(VLAN_TAG);
		BPF_ANCILLARY(VLAN_TAG_PRESENT);
		BPF_ANCILLARY(PAY_OFFSET);
		BPF_ANCILLARY(RANDOM);
717
		BPF_ANCILLARY(VLAN_TPID);
718 719 720 721 722 723 724
		}
		/* Fallthrough. */
	default:
		return ftest->code;
	}
}

725 726 727 728 729 730 731 732 733 734 735 736
void *bpf_internal_load_pointer_neg_helper(const struct sk_buff *skb,
					   int k, unsigned int size);

static inline void *bpf_load_pointer(const struct sk_buff *skb, int k,
				     unsigned int size, void *buffer)
{
	if (k >= 0)
		return skb_header_pointer(skb, k, size, buffer);

	return bpf_internal_load_pointer_neg_helper(skb, k, size);
}

737 738
static inline int bpf_tell_extensions(void)
{
739
	return SKF_AD_MAX;
740 741
}

L
Linus Torvalds 已提交
742
#endif /* __LINUX_FILTER_H__ */