Subject: linux-next: manual merge of the bpf-next tree with Linus' tree

From: Stephen Rothwell <[email-masked]>
Date: Fri, 21 Dec 2018 13:36:17 +1100

Hi all,

Today's linux-next merge of the bpf-next tree got a conflict in:

  tools/testing/selftests/bpf/test_verifier.c

between commits:

  7640ead93924 ("bpf: verifier: make sure callees don't prune with caller differences")
  14507e35bd9d ("selftests: bpf: verifier: add tests for JSET interpretation")

from Linus' tree and commit:

  5a8d5209ac02 ("selftests: bpf: add trivial JSET tests")

from the bpf-next tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

-- 
Cheers,
Stephen Rothwell

diff --cc tools/testing/selftests/bpf/test_verifier.c
index c3b799c1ee97,dbd31750b214..000000000000
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@@ -14098,34 -14169,198 +14169,225 @@@ static struct bpf_test tests[] = 
  		.errstr = "invalid bpf_context access",
  		.errstr_unpriv = "R1 leaks addr",
  		.result = REJECT,
 +	},
 +		"calls: cross frame pruning",
 +		.insns = {
 +			/* r8 = !!random();
 +			 * call pruner()
 +			 * if (r8)
 +			 *     do something bad;
 +			 */
 +			BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
 +				     BPF_FUNC_get_prandom_u32),
 +			BPF_MOV64_IMM(BPF_REG_8, 0),
 +			BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
 +			BPF_MOV64_IMM(BPF_REG_8, 1),
 +			BPF_MOV64_REG(BPF_REG_1, BPF_REG_8),
 +			BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4),
 +			BPF_JMP_IMM(BPF_JEQ, BPF_REG_8, 1, 1),
 +			BPF_LDX_MEM(BPF_B, BPF_REG_9, BPF_REG_1, 0),
 +			BPF_MOV64_IMM(BPF_REG_0, 0),
 +			BPF_EXIT_INSN(),
 +			BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 0),
 +			BPF_EXIT_INSN(),
 +		},
 +		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
 +		.errstr_unpriv = "function calls to other bpf functions are allowed for root only",
 +		.result_unpriv = REJECT,
 +		.errstr = "!read_ok",
 +		.result = REJECT,
  	},
+ 	{
+ 		"jset: functional",
+ 		.insns = {
+ 			/* r0 = 0 */
+ 			BPF_MOV64_IMM(BPF_REG_0, 0),
+ 			/* prep for direct packet access via r2 */
+ 			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+ 				    offsetof(struct __sk_buff, data)),
+ 			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+ 				    offsetof(struct __sk_buff, data_end)),
+ 			BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),
+ 			BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),
+ 			BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+ 
+ 			/* reg, bit 63 or bit 0 set, taken */
+ 			BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
+ 			BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			/* reg, bit 62, not taken */
+ 			BPF_LD_IMM64(BPF_REG_8, 0x4000000000000000),
+ 			BPF_JMP_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
+ 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			/* imm, any bit set, taken */
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_7, -1, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			/* imm, bit 31 set, taken */
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_7, 0x80000000, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			/* all good - return r0 == 2 */
+ 			BPF_MOV64_IMM(BPF_REG_0, 2),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
+ 		.result = ACCEPT,
+ 		.runs = 7,
+ 		.retvals = {
+ 			{ .retval = 2,
+ 			  .data64 = { (1ULL << 63) | (1U << 31) | (1U << 0), }
+ 			},
+ 			{ .retval = 2,
+ 			  .data64 = { (1ULL << 63) | (1U << 31), }
+ 			},
+ 			{ .retval = 2,
+ 			  .data64 = { (1ULL << 31) | (1U << 0), }
+ 			},
+ 			{ .retval = 2,
+ 			  .data64 = { (__u32)-1, }
+ 			},
+ 			{ .retval = 2,
+ 			  .data64 = { ~0x4000000000000000ULL, }
+ 			},
+ 			{ .retval = 0,
+ 			  .data64 = { 0, }
+ 			},
+ 			{ .retval = 0,
+ 			  .data64 = { ~0ULL, }
+ 			},
+ 		},
+ 	},
+ 	{
+ 		"jset: sign-extend",
+ 		.insns = {
+ 			/* r0 = 0 */
+ 			BPF_MOV64_IMM(BPF_REG_0, 0),
+ 			/* prep for direct packet access via r2 */
+ 			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
+ 				    offsetof(struct __sk_buff, data)),
+ 			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
+ 				    offsetof(struct __sk_buff, data_end)),
+ 			BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),
+ 			BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),
+ 			BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+ 
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_7, 0x80000000, 1),
+ 			BPF_EXIT_INSN(),
+ 
+ 			BPF_MOV64_IMM(BPF_REG_0, 2),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
+ 		.result = ACCEPT,
+ 		.retval = 2,
+ 		.data = { 1, 0, 0, 0, 0, 0, 0, 1, },
+ 	},
+ 	{
+ 		"jset: known const compare",
+ 		.insns = {
+ 			BPF_MOV64_IMM(BPF_REG_0, 1),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+ 		.retval_unpriv = 1,
+ 		.result_unpriv = ACCEPT,
+ 		.retval = 1,
+ 		.result = ACCEPT,
+ 	},
+ 	{
+ 		"jset: known const compare bad",
+ 		.insns = {
+ 			BPF_MOV64_IMM(BPF_REG_0, 0),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+ 		.errstr_unpriv = "!read_ok",
+ 		.result_unpriv = REJECT,
+ 		.errstr = "!read_ok",
+ 		.result = REJECT,
+ 	},
+ 	{
+ 		"jset: unknown const compare taken",
+ 		.insns = {
+ 			BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+ 				     BPF_FUNC_get_prandom_u32),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+ 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+ 		.errstr_unpriv = "!read_ok",
+ 		.result_unpriv = REJECT,
+ 		.errstr = "!read_ok",
+ 		.result = REJECT,
+ 	},
+ 	{
+ 		"jset: unknown const compare not taken",
+ 		.insns = {
+ 			BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+ 				     BPF_FUNC_get_prandom_u32),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 1, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+ 		.errstr_unpriv = "!read_ok",
+ 		.result_unpriv = REJECT,
+ 		.errstr = "!read_ok",
+ 		.result = REJECT,
+ 	},
+ 	{
+ 		"jset: half-known const compare",
+ 		.insns = {
+ 			BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+ 				     BPF_FUNC_get_prandom_u32),
+ 			BPF_ALU64_IMM(BPF_OR, BPF_REG_0, 2),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_0, 3, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_MOV64_IMM(BPF_REG_0, 0),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+ 		.result_unpriv = ACCEPT,
+ 		.result = ACCEPT,
+ 	},
+ 	{
+ 		"jset: range",
+ 		.insns = {
+ 			BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,
+ 				     BPF_FUNC_get_prandom_u32),
+ 			BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+ 			BPF_MOV64_IMM(BPF_REG_0, 0),
+ 			BPF_ALU64_IMM(BPF_AND, BPF_REG_1, 0xff),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_1, 0xf0, 3),
+ 			BPF_JMP_IMM(BPF_JLT, BPF_REG_1, 0x10, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_EXIT_INSN(),
+ 			BPF_JMP_IMM(BPF_JSET, BPF_REG_1, 0x10, 1),
+ 			BPF_EXIT_INSN(),
+ 			BPF_JMP_IMM(BPF_JGE, BPF_REG_1, 0x10, 1),
+ 			BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+ 			BPF_EXIT_INSN(),
+ 		},
+ 		.prog_type = BPF_PROG_TYPE_SOCKET_FILTER,
+ 		.result_unpriv = ACCEPT,
+ 		.result = ACCEPT,
+ 	},
  };
  
  static int probe_filter_length(const struct bpf_insn *fp)