Commit 8556ce79 authored by Daniel Borkmann's avatar Daniel Borkmann Committed by David S. Miller
Browse files

net: filter: remove DL macro 



Lets get rid of this macro. After commit 5bcfedf0 ("net: filter:
simplify label names from jump-table"), labels have become more
readable due to omission of BPF_ prefix but at the same time more
generic, so that things like `git grep -n` would not find them. As
a middle path, lets get rid of the DL macro as it's not strictly
needed and would otherwise just hide the full name.

Signed-off-by: default avatarDaniel Borkmann <dborkman@redhat.com>
Acked-by: default avatarAlexei Starovoitov <ast@plumgrid.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 76fcee24

include/linux/filter.h

+0 −3
Original line number Diff line number Diff line
@@ -37,9 +37,6 @@ 
#define BPF_CALL	0x80	/* function call */

#define BPF_EXIT	0x90	/* function return */



/* Placeholder/dummy for 0 */

#define BPF_0		0



/* Register numbers */

enum {

	BPF_REG_0 = 0,

net/core/filter.c

+99 −94
Original line number Diff line number Diff line
@@ -160,95 +160,100 @@ static unsigned int __sk_run_filter(void *ctx, const struct sock_filter_int *ins 
	static const void *jumptable[256] = {

		[0 ... 255] = &&default_label,

		/* Now overwrite non-defaults ... */

#define DL(A, B, C)	[BPF_##A|BPF_##B|BPF_##C] = &&A##_##B##_##C

		DL(ALU, ADD, X),

		DL(ALU, ADD, K),

		DL(ALU, SUB, X),

		DL(ALU, SUB, K),

		DL(ALU, AND, X),

		DL(ALU, AND, K),

		DL(ALU, OR, X),

		DL(ALU, OR, K),

		DL(ALU, LSH, X),

		DL(ALU, LSH, K),

		DL(ALU, RSH, X),

		DL(ALU, RSH, K),

		DL(ALU, XOR, X),

		DL(ALU, XOR, K),

		DL(ALU, MUL, X),

		DL(ALU, MUL, K),

		DL(ALU, MOV, X),

		DL(ALU, MOV, K),

		DL(ALU, DIV, X),

		DL(ALU, DIV, K),

		DL(ALU, MOD, X),

		DL(ALU, MOD, K),

		DL(ALU, NEG, 0),

		DL(ALU, END, TO_BE),

		DL(ALU, END, TO_LE),

		DL(ALU64, ADD, X),

		DL(ALU64, ADD, K),

		DL(ALU64, SUB, X),

		DL(ALU64, SUB, K),

		DL(ALU64, AND, X),

		DL(ALU64, AND, K),

		DL(ALU64, OR, X),

		DL(ALU64, OR, K),

		DL(ALU64, LSH, X),

		DL(ALU64, LSH, K),

		DL(ALU64, RSH, X),

		DL(ALU64, RSH, K),

		DL(ALU64, XOR, X),

		DL(ALU64, XOR, K),

		DL(ALU64, MUL, X),

		DL(ALU64, MUL, K),

		DL(ALU64, MOV, X),

		DL(ALU64, MOV, K),

		DL(ALU64, ARSH, X),

		DL(ALU64, ARSH, K),

		DL(ALU64, DIV, X),

		DL(ALU64, DIV, K),

		DL(ALU64, MOD, X),

		DL(ALU64, MOD, K),

		DL(ALU64, NEG, 0),

		DL(JMP, CALL, 0),

		DL(JMP, JA, 0),

		DL(JMP, JEQ, X),

		DL(JMP, JEQ, K),

		DL(JMP, JNE, X),

		DL(JMP, JNE, K),

		DL(JMP, JGT, X),

		DL(JMP, JGT, K),

		DL(JMP, JGE, X),

		DL(JMP, JGE, K),

		DL(JMP, JSGT, X),

		DL(JMP, JSGT, K),

		DL(JMP, JSGE, X),

		DL(JMP, JSGE, K),

		DL(JMP, JSET, X),

		DL(JMP, JSET, K),

		DL(JMP, EXIT, 0),

		DL(STX, MEM, B),

		DL(STX, MEM, H),

		DL(STX, MEM, W),

		DL(STX, MEM, DW),

		DL(STX, XADD, W),

		DL(STX, XADD, DW),

		DL(ST, MEM, B),

		DL(ST, MEM, H),

		DL(ST, MEM, W),

		DL(ST, MEM, DW),

		DL(LDX, MEM, B),

		DL(LDX, MEM, H),

		DL(LDX, MEM, W),

		DL(LDX, MEM, DW),

		DL(LD, ABS, W),

		DL(LD, ABS, H),

		DL(LD, ABS, B),

		DL(LD, IND, W),

		DL(LD, IND, H),

		DL(LD, IND, B),

#undef DL

		/* 32 bit ALU operations */

		[BPF_ALU | BPF_ADD | BPF_X] = &&ALU_ADD_X,

		[BPF_ALU | BPF_ADD | BPF_K] = &&ALU_ADD_K,

		[BPF_ALU | BPF_SUB | BPF_X] = &&ALU_SUB_X,

		[BPF_ALU | BPF_SUB | BPF_K] = &&ALU_SUB_K,

		[BPF_ALU | BPF_AND | BPF_X] = &&ALU_AND_X,

		[BPF_ALU | BPF_AND | BPF_K] = &&ALU_AND_K,

		[BPF_ALU | BPF_OR | BPF_X]  = &&ALU_OR_X,

		[BPF_ALU | BPF_OR | BPF_K]  = &&ALU_OR_K,

		[BPF_ALU | BPF_LSH | BPF_X] = &&ALU_LSH_X,

		[BPF_ALU | BPF_LSH | BPF_K] = &&ALU_LSH_K,

		[BPF_ALU | BPF_RSH | BPF_X] = &&ALU_RSH_X,

		[BPF_ALU | BPF_RSH | BPF_K] = &&ALU_RSH_K,

		[BPF_ALU | BPF_XOR | BPF_X] = &&ALU_XOR_X,

		[BPF_ALU | BPF_XOR | BPF_K] = &&ALU_XOR_K,

		[BPF_ALU | BPF_MUL | BPF_X] = &&ALU_MUL_X,

		[BPF_ALU | BPF_MUL | BPF_K] = &&ALU_MUL_K,

		[BPF_ALU | BPF_MOV | BPF_X] = &&ALU_MOV_X,

		[BPF_ALU | BPF_MOV | BPF_K] = &&ALU_MOV_K,

		[BPF_ALU | BPF_DIV | BPF_X] = &&ALU_DIV_X,

		[BPF_ALU | BPF_DIV | BPF_K] = &&ALU_DIV_K,

		[BPF_ALU | BPF_MOD | BPF_X] = &&ALU_MOD_X,

		[BPF_ALU | BPF_MOD | BPF_K] = &&ALU_MOD_K,

		[BPF_ALU | BPF_NEG] = &&ALU_NEG,

		[BPF_ALU | BPF_END | BPF_TO_BE] = &&ALU_END_TO_BE,

		[BPF_ALU | BPF_END | BPF_TO_LE] = &&ALU_END_TO_LE,

		/* 64 bit ALU operations */

		[BPF_ALU64 | BPF_ADD | BPF_X] = &&ALU64_ADD_X,

		[BPF_ALU64 | BPF_ADD | BPF_K] = &&ALU64_ADD_K,

		[BPF_ALU64 | BPF_SUB | BPF_X] = &&ALU64_SUB_X,

		[BPF_ALU64 | BPF_SUB | BPF_K] = &&ALU64_SUB_K,

		[BPF_ALU64 | BPF_AND | BPF_X] = &&ALU64_AND_X,

		[BPF_ALU64 | BPF_AND | BPF_K] = &&ALU64_AND_K,

		[BPF_ALU64 | BPF_OR | BPF_X] = &&ALU64_OR_X,

		[BPF_ALU64 | BPF_OR | BPF_K] = &&ALU64_OR_K,

		[BPF_ALU64 | BPF_LSH | BPF_X] = &&ALU64_LSH_X,

		[BPF_ALU64 | BPF_LSH | BPF_K] = &&ALU64_LSH_K,

		[BPF_ALU64 | BPF_RSH | BPF_X] = &&ALU64_RSH_X,

		[BPF_ALU64 | BPF_RSH | BPF_K] = &&ALU64_RSH_K,

		[BPF_ALU64 | BPF_XOR | BPF_X] = &&ALU64_XOR_X,

		[BPF_ALU64 | BPF_XOR | BPF_K] = &&ALU64_XOR_K,

		[BPF_ALU64 | BPF_MUL | BPF_X] = &&ALU64_MUL_X,

		[BPF_ALU64 | BPF_MUL | BPF_K] = &&ALU64_MUL_K,

		[BPF_ALU64 | BPF_MOV | BPF_X] = &&ALU64_MOV_X,

		[BPF_ALU64 | BPF_MOV | BPF_K] = &&ALU64_MOV_K,

		[BPF_ALU64 | BPF_ARSH | BPF_X] = &&ALU64_ARSH_X,

		[BPF_ALU64 | BPF_ARSH | BPF_K] = &&ALU64_ARSH_K,

		[BPF_ALU64 | BPF_DIV | BPF_X] = &&ALU64_DIV_X,

		[BPF_ALU64 | BPF_DIV | BPF_K] = &&ALU64_DIV_K,

		[BPF_ALU64 | BPF_MOD | BPF_X] = &&ALU64_MOD_X,

		[BPF_ALU64 | BPF_MOD | BPF_K] = &&ALU64_MOD_K,

		[BPF_ALU64 | BPF_NEG] = &&ALU64_NEG,

		/* Call instruction */

		[BPF_JMP | BPF_CALL] = &&JMP_CALL,

		/* Jumps */

		[BPF_JMP | BPF_JA] = &&JMP_JA,

		[BPF_JMP | BPF_JEQ | BPF_X] = &&JMP_JEQ_X,

		[BPF_JMP | BPF_JEQ | BPF_K] = &&JMP_JEQ_K,

		[BPF_JMP | BPF_JNE | BPF_X] = &&JMP_JNE_X,

		[BPF_JMP | BPF_JNE | BPF_K] = &&JMP_JNE_K,

		[BPF_JMP | BPF_JGT | BPF_X] = &&JMP_JGT_X,

		[BPF_JMP | BPF_JGT | BPF_K] = &&JMP_JGT_K,

		[BPF_JMP | BPF_JGE | BPF_X] = &&JMP_JGE_X,

		[BPF_JMP | BPF_JGE | BPF_K] = &&JMP_JGE_K,

		[BPF_JMP | BPF_JSGT | BPF_X] = &&JMP_JSGT_X,

		[BPF_JMP | BPF_JSGT | BPF_K] = &&JMP_JSGT_K,

		[BPF_JMP | BPF_JSGE | BPF_X] = &&JMP_JSGE_X,

		[BPF_JMP | BPF_JSGE | BPF_K] = &&JMP_JSGE_K,

		[BPF_JMP | BPF_JSET | BPF_X] = &&JMP_JSET_X,

		[BPF_JMP | BPF_JSET | BPF_K] = &&JMP_JSET_K,

		/* Program return */

		[BPF_JMP | BPF_EXIT] = &&JMP_EXIT,

		/* Store instructions */

		[BPF_STX | BPF_MEM | BPF_B] = &&STX_MEM_B,

		[BPF_STX | BPF_MEM | BPF_H] = &&STX_MEM_H,

		[BPF_STX | BPF_MEM | BPF_W] = &&STX_MEM_W,

		[BPF_STX | BPF_MEM | BPF_DW] = &&STX_MEM_DW,

		[BPF_STX | BPF_XADD | BPF_W] = &&STX_XADD_W,

		[BPF_STX | BPF_XADD | BPF_DW] = &&STX_XADD_DW,

		[BPF_ST | BPF_MEM | BPF_B] = &&ST_MEM_B,

		[BPF_ST | BPF_MEM | BPF_H] = &&ST_MEM_H,

		[BPF_ST | BPF_MEM | BPF_W] = &&ST_MEM_W,

		[BPF_ST | BPF_MEM | BPF_DW] = &&ST_MEM_DW,

		/* Load instructions */

		[BPF_LDX | BPF_MEM | BPF_B] = &&LDX_MEM_B,

		[BPF_LDX | BPF_MEM | BPF_H] = &&LDX_MEM_H,

		[BPF_LDX | BPF_MEM | BPF_W] = &&LDX_MEM_W,

		[BPF_LDX | BPF_MEM | BPF_DW] = &&LDX_MEM_DW,

		[BPF_LD | BPF_ABS | BPF_W] = &&LD_ABS_W,

		[BPF_LD | BPF_ABS | BPF_H] = &&LD_ABS_H,

		[BPF_LD | BPF_ABS | BPF_B] = &&LD_ABS_B,

		[BPF_LD | BPF_IND | BPF_W] = &&LD_IND_W,

		[BPF_LD | BPF_IND | BPF_H] = &&LD_IND_H,

		[BPF_LD | BPF_IND | BPF_B] = &&LD_IND_B,

	};

	void *ptr;

	int off;
@@ -290,10 +295,10 @@ select_insn: 
	ALU(XOR,  ^)

	ALU(MUL,  *)

#undef ALU

	ALU_NEG_0:

	ALU_NEG:

		A = (u32) -A;

		CONT;

	ALU64_NEG_0:

	ALU64_NEG:

		A = -A;

		CONT;

	ALU_MOV_X:
@@ -382,7 +387,7 @@ select_insn: 
		CONT;



	/* CALL */

	JMP_CALL_0:

	JMP_CALL:

		/* Function call scratches BPF_R1-BPF_R5 registers,

		 * preserves BPF_R6-BPF_R9, and stores return value

		 * into BPF_R0.
@@ -392,7 +397,7 @@ select_insn: 
		CONT;



	/* JMP */

	JMP_JA_0:

	JMP_JA:

		insn += insn->off;

		CONT;

	JMP_JEQ_X:
@@ -479,7 +484,7 @@ select_insn: 
			CONT_JMP;

		}

		CONT;

	JMP_EXIT_0:

	JMP_EXIT:

		return BPF_R0;



	/* STX and ST and LDX*/

CRA Git | Maintained and supported by SUSTech CRA and CCSE