* [PATCH net-next 0/2] BPF test suite update
@ 2014-05-26 18:17 Daniel Borkmann
2014-05-26 18:17 ` [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs Daniel Borkmann
` (2 more replies)
0 siblings, 3 replies; 8+ messages in thread
From: Daniel Borkmann @ 2014-05-26 18:17 UTC (permalink / raw)
To: davem; +Cc: ast, netdev
Daniel Borkmann (2):
net: filter: test fill/spill of all M[] regs
net: filter: use block statements in tcpdump tests
lib/test_bpf.c | 233 ++++++++++++++++++++++++++++++++++++++++-----------------
1 file changed, 165 insertions(+), 68 deletions(-)
--
1.7.11.7
^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs
2014-05-26 18:17 [PATCH net-next 0/2] BPF test suite update Daniel Borkmann
@ 2014-05-26 18:17 ` Daniel Borkmann
2014-05-27 6:02 ` Alexei Starovoitov
2014-05-26 18:17 ` [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests Daniel Borkmann
2014-05-30 23:27 ` [PATCH net-next 0/2] BPF test suite update David Miller
2 siblings, 1 reply; 8+ messages in thread
From: Daniel Borkmann @ 2014-05-26 18:17 UTC (permalink / raw)
To: davem; +Cc: ast, netdev
This test for classic BPF probes stores and load combination
via X on all 16 registers of the scratch memory store. It
initially loads integer 100 and passes this value around
to each register while incrementing it every time, thus we
expect to have 116 as a result. Might be useful for JIT
testing.
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
---
lib/test_bpf.c | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 90 insertions(+)
diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index af677cb..6be9119 100644
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -1485,6 +1485,96 @@ static struct bpf_test tests[] = {
{ },
{ },
},
+ { /* Mainly checking JIT here. */
+ "M[]: STX + LDX",
+ .u.insns = {
+ BPF_STMT(BPF_LDX | BPF_IMM, 100),
+ BPF_STMT(BPF_STX, 0),
+ BPF_STMT(BPF_LDX | BPF_MEM, 0),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 1),
+ BPF_STMT(BPF_LDX | BPF_MEM, 1),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 2),
+ BPF_STMT(BPF_LDX | BPF_MEM, 2),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 3),
+ BPF_STMT(BPF_LDX | BPF_MEM, 3),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 4),
+ BPF_STMT(BPF_LDX | BPF_MEM, 4),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 5),
+ BPF_STMT(BPF_LDX | BPF_MEM, 5),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 6),
+ BPF_STMT(BPF_LDX | BPF_MEM, 6),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 7),
+ BPF_STMT(BPF_LDX | BPF_MEM, 7),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 8),
+ BPF_STMT(BPF_LDX | BPF_MEM, 8),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 9),
+ BPF_STMT(BPF_LDX | BPF_MEM, 9),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 10),
+ BPF_STMT(BPF_LDX | BPF_MEM, 10),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 11),
+ BPF_STMT(BPF_LDX | BPF_MEM, 11),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 12),
+ BPF_STMT(BPF_LDX | BPF_MEM, 12),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 13),
+ BPF_STMT(BPF_LDX | BPF_MEM, 13),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 14),
+ BPF_STMT(BPF_LDX | BPF_MEM, 14),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_STX, 15),
+ BPF_STMT(BPF_LDX | BPF_MEM, 15),
+ BPF_STMT(BPF_MISC | BPF_TXA, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0),
+ BPF_STMT(BPF_RET | BPF_A, 0),
+ },
+ CLASSIC | FLAG_NO_DATA,
+ { },
+ { { 0, 116 } },
+ },
};
static struct net_device dev;
--
1.7.11.7
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests
2014-05-26 18:17 [PATCH net-next 0/2] BPF test suite update Daniel Borkmann
2014-05-26 18:17 ` [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs Daniel Borkmann
@ 2014-05-26 18:17 ` Daniel Borkmann
2014-05-27 6:20 ` Alexei Starovoitov
2014-05-30 23:27 ` [PATCH net-next 0/2] BPF test suite update David Miller
2 siblings, 1 reply; 8+ messages in thread
From: Daniel Borkmann @ 2014-05-26 18:17 UTC (permalink / raw)
To: davem; +Cc: ast, netdev
This patch converts raw opcodes for tcpdump tests into
BPF_STMT()/BPF_JUMP() combinations, which brings it into
conformity with the rest of the patches and it also makes
life easier to grasp what's going on in these particular
test cases when they ever fail. Also arrange payload from
the jump+holes test in a way as we have with other packet
payloads in the test suite.
Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
---
lib/test_bpf.c | 143 ++++++++++++++++++++++++++++++---------------------------
1 file changed, 75 insertions(+), 68 deletions(-)
diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index 6be9119..3c4a1e3 100644
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -560,30 +560,30 @@ static struct bpf_test tests[] = {
{
"tcpdump port 22",
.u.insns = {
- { 0x28, 0, 0, 0x0000000c },
- { 0x15, 0, 8, 0x000086dd },
- { 0x30, 0, 0, 0x00000014 },
- { 0x15, 2, 0, 0x00000084 },
- { 0x15, 1, 0, 0x00000006 },
- { 0x15, 0, 17, 0x00000011 },
- { 0x28, 0, 0, 0x00000036 },
- { 0x15, 14, 0, 0x00000016 },
- { 0x28, 0, 0, 0x00000038 },
- { 0x15, 12, 13, 0x00000016 },
- { 0x15, 0, 12, 0x00000800 },
- { 0x30, 0, 0, 0x00000017 },
- { 0x15, 2, 0, 0x00000084 },
- { 0x15, 1, 0, 0x00000006 },
- { 0x15, 0, 8, 0x00000011 },
- { 0x28, 0, 0, 0x00000014 },
- { 0x45, 6, 0, 0x00001fff },
- { 0xb1, 0, 0, 0x0000000e },
- { 0x48, 0, 0, 0x0000000e },
- { 0x15, 2, 0, 0x00000016 },
- { 0x48, 0, 0, 0x00000010 },
- { 0x15, 0, 1, 0x00000016 },
- { 0x06, 0, 0, 0x0000ffff },
- { 0x06, 0, 0, 0x00000000 },
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
+ BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
+ BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
+ BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
+ BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
+ BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
+ BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
+ BPF_STMT(BPF_RET | BPF_K, 0xffff),
+ BPF_STMT(BPF_RET | BPF_K, 0),
},
CLASSIC,
/* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
@@ -609,39 +609,39 @@ static struct bpf_test tests[] = {
* ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
* (len > 115 or len < 30000000000)' -d
*/
- { 0x28, 0, 0, 0x0000000c },
- { 0x15, 30, 0, 0x000086dd },
- { 0x15, 0, 29, 0x00000800 },
- { 0x30, 0, 0, 0x00000017 },
- { 0x15, 0, 27, 0x00000006 },
- { 0x28, 0, 0, 0x00000014 },
- { 0x45, 25, 0, 0x00001fff },
- { 0xb1, 0, 0, 0x0000000e },
- { 0x48, 0, 0, 0x0000000e },
- { 0x15, 2, 0, 0x00000016 },
- { 0x48, 0, 0, 0x00000010 },
- { 0x15, 0, 20, 0x00000016 },
- { 0x28, 0, 0, 0x00000010 },
- { 0x02, 0, 0, 0x00000001 },
- { 0x30, 0, 0, 0x0000000e },
- { 0x54, 0, 0, 0x0000000f },
- { 0x64, 0, 0, 0x00000002 },
- { 0x07, 0, 0, 0x00000005 },
- { 0x60, 0, 0, 0x00000001 },
- { 0x1c, 0, 0, 0x00000000 },
- { 0x02, 0, 0, 0x00000005 },
- { 0xb1, 0, 0, 0x0000000e },
- { 0x50, 0, 0, 0x0000001a },
- { 0x54, 0, 0, 0x000000f0 },
- { 0x74, 0, 0, 0x00000002 },
- { 0x07, 0, 0, 0x00000009 },
- { 0x60, 0, 0, 0x00000005 },
- { 0x1d, 4, 0, 0x00000000 },
- { 0x80, 0, 0, 0x00000000 },
- { 0x25, 1, 0, 0x00000073 },
- { 0x35, 1, 0, 0xfc23ac00 },
- { 0x06, 0, 0, 0x0000ffff },
- { 0x06, 0, 0, 0x00000000 },
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
+ BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
+ BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
+ BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
+ BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
+ BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
+ BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
+ BPF_STMT(BPF_ST, 1),
+ BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
+ BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
+ BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
+ BPF_STMT(BPF_LD | BPF_MEM, 1),
+ BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
+ BPF_STMT(BPF_ST, 5),
+ BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
+ BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
+ BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
+ BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
+ BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
+ BPF_STMT(BPF_LD | BPF_MEM, 5),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
+ BPF_STMT(BPF_LD | BPF_LEN, 0),
+ BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
+ BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
+ BPF_STMT(BPF_RET | BPF_K, 0xffff),
+ BPF_STMT(BPF_RET | BPF_K, 0),
},
CLASSIC,
{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
@@ -1453,17 +1453,24 @@ static struct bpf_test tests[] = {
BPF_STMT(BPF_RET | BPF_A, 0),
},
CLASSIC,
- { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 0x90, 0xe2,
- 0xba, 0x0a, 0x56, 0xb4, 0x08, 0x00, 0x45, 0x00,
- 0x00, 0x28, 0x00, 0x00, 0x20, 0x00, 0x40, 0x11,
- 0x00, 0x00, 0xc0, 0xa8, 0x33, 0x01, 0xc0, 0xa8,
- 0x33, 0x02, 0xbb, 0xb6, 0xa9, 0xfa, 0x00, 0x14,
- 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
- 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
- 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
- 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
- 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
- 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc },
+ { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
+ 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
+ 0x08, 0x00,
+ 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
+ 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
+ 0xc0, 0xa8, 0x33, 0x01,
+ 0xc0, 0xa8, 0x33, 0x02,
+ 0xbb, 0xb6,
+ 0xa9, 0xfa,
+ 0x00, 0x14, 0x00, 0x00,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
+ 0xcc, 0xcc, 0xcc, 0xcc },
{ { 88, 0x001b } }
},
{
--
1.7.11.7
^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs
2014-05-26 18:17 ` [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs Daniel Borkmann
@ 2014-05-27 6:02 ` Alexei Starovoitov
2014-05-27 16:57 ` Daniel Borkmann
0 siblings, 1 reply; 8+ messages in thread
From: Alexei Starovoitov @ 2014-05-27 6:02 UTC (permalink / raw)
To: Daniel Borkmann; +Cc: David S. Miller, Network Development
On Mon, May 26, 2014 at 11:17 AM, Daniel Borkmann <dborkman@redhat.com> wrote:
> This test for classic BPF probes stores and load combination
> via X on all 16 registers of the scratch memory store. It
> initially loads integer 100 and passes this value around
> to each register while incrementing it every time, thus we
> expect to have 116 as a result. Might be useful for JIT
> testing.
>
> Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Looks good. The more tests the better.
Acked-by: Alexei Starovoitov <ast@plumgrid.com>
> ---
> lib/test_bpf.c | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 90 insertions(+)
>
> diff --git a/lib/test_bpf.c b/lib/test_bpf.c
> index af677cb..6be9119 100644
> --- a/lib/test_bpf.c
> +++ b/lib/test_bpf.c
> @@ -1485,6 +1485,96 @@ static struct bpf_test tests[] = {
> { },
> { },
> },
> + { /* Mainly checking JIT here. */
> + "M[]: STX + LDX",
> + .u.insns = {
> + BPF_STMT(BPF_LDX | BPF_IMM, 100),
> + BPF_STMT(BPF_STX, 0),
> + BPF_STMT(BPF_LDX | BPF_MEM, 0),
store and immediate load from the same slot won't catch slot overlap,
but that would be a job for another test.
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 1),
> + BPF_STMT(BPF_LDX | BPF_MEM, 1),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 2),
> + BPF_STMT(BPF_LDX | BPF_MEM, 2),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 3),
> + BPF_STMT(BPF_LDX | BPF_MEM, 3),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 4),
> + BPF_STMT(BPF_LDX | BPF_MEM, 4),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 5),
> + BPF_STMT(BPF_LDX | BPF_MEM, 5),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 6),
> + BPF_STMT(BPF_LDX | BPF_MEM, 6),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 7),
> + BPF_STMT(BPF_LDX | BPF_MEM, 7),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 8),
> + BPF_STMT(BPF_LDX | BPF_MEM, 8),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 9),
> + BPF_STMT(BPF_LDX | BPF_MEM, 9),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 10),
> + BPF_STMT(BPF_LDX | BPF_MEM, 10),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 11),
> + BPF_STMT(BPF_LDX | BPF_MEM, 11),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 12),
> + BPF_STMT(BPF_LDX | BPF_MEM, 12),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 13),
> + BPF_STMT(BPF_LDX | BPF_MEM, 13),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 14),
> + BPF_STMT(BPF_LDX | BPF_MEM, 14),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_STX, 15),
> + BPF_STMT(BPF_LDX | BPF_MEM, 15),
> + BPF_STMT(BPF_MISC | BPF_TXA, 0),
> + BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0),
> + BPF_STMT(BPF_RET | BPF_A, 0),
> + },
> + CLASSIC | FLAG_NO_DATA,
> + { },
> + { { 0, 116 } },
> + },
> };
>
> static struct net_device dev;
> --
> 1.7.11.7
>
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests
2014-05-26 18:17 ` [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests Daniel Borkmann
@ 2014-05-27 6:20 ` Alexei Starovoitov
2014-05-27 17:00 ` Daniel Borkmann
0 siblings, 1 reply; 8+ messages in thread
From: Alexei Starovoitov @ 2014-05-27 6:20 UTC (permalink / raw)
To: Daniel Borkmann; +Cc: David S. Miller, Network Development
On Mon, May 26, 2014 at 11:17 AM, Daniel Borkmann <dborkman@redhat.com> wrote:
> This patch converts raw opcodes for tcpdump tests into
> BPF_STMT()/BPF_JUMP() combinations, which brings it into
> conformity with the rest of the patches and it also makes
> life easier to grasp what's going on in these particular
> test cases when they ever fail. Also arrange payload from
> the jump+holes test in a way as we have with other packet
> payloads in the test suite.
>
> Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Acked-by: Alexei Starovoitov <ast@plumgrid.com>
> ---
> lib/test_bpf.c | 143 ++++++++++++++++++++++++++++++---------------------------
> 1 file changed, 75 insertions(+), 68 deletions(-)
>
> diff --git a/lib/test_bpf.c b/lib/test_bpf.c
> index 6be9119..3c4a1e3 100644
> --- a/lib/test_bpf.c
> +++ b/lib/test_bpf.c
> @@ -560,30 +560,30 @@ static struct bpf_test tests[] = {
> {
> "tcpdump port 22",
> .u.insns = {
> - { 0x28, 0, 0, 0x0000000c },
> - { 0x15, 0, 8, 0x000086dd },
> - { 0x30, 0, 0, 0x00000014 },
> - { 0x15, 2, 0, 0x00000084 },
> - { 0x15, 1, 0, 0x00000006 },
> - { 0x15, 0, 17, 0x00000011 },
> - { 0x28, 0, 0, 0x00000036 },
> - { 0x15, 14, 0, 0x00000016 },
> - { 0x28, 0, 0, 0x00000038 },
> - { 0x15, 12, 13, 0x00000016 },
> - { 0x15, 0, 12, 0x00000800 },
> - { 0x30, 0, 0, 0x00000017 },
> - { 0x15, 2, 0, 0x00000084 },
> - { 0x15, 1, 0, 0x00000006 },
> - { 0x15, 0, 8, 0x00000011 },
> - { 0x28, 0, 0, 0x00000014 },
> - { 0x45, 6, 0, 0x00001fff },
> - { 0xb1, 0, 0, 0x0000000e },
> - { 0x48, 0, 0, 0x0000000e },
> - { 0x15, 2, 0, 0x00000016 },
> - { 0x48, 0, 0, 0x00000010 },
> - { 0x15, 0, 1, 0x00000016 },
> - { 0x06, 0, 0, 0x0000ffff },
> - { 0x06, 0, 0, 0x00000000 },
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
> + BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
> + BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
> + BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
> + BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
> + BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
> + BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
> + BPF_STMT(BPF_RET | BPF_K, 0xffff),
> + BPF_STMT(BPF_RET | BPF_K, 0),
> },
> CLASSIC,
> /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
> @@ -609,39 +609,39 @@ static struct bpf_test tests[] = {
> * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
> * (len > 115 or len < 30000000000)' -d
> */
> - { 0x28, 0, 0, 0x0000000c },
> - { 0x15, 30, 0, 0x000086dd },
> - { 0x15, 0, 29, 0x00000800 },
> - { 0x30, 0, 0, 0x00000017 },
> - { 0x15, 0, 27, 0x00000006 },
> - { 0x28, 0, 0, 0x00000014 },
> - { 0x45, 25, 0, 0x00001fff },
> - { 0xb1, 0, 0, 0x0000000e },
> - { 0x48, 0, 0, 0x0000000e },
> - { 0x15, 2, 0, 0x00000016 },
> - { 0x48, 0, 0, 0x00000010 },
> - { 0x15, 0, 20, 0x00000016 },
> - { 0x28, 0, 0, 0x00000010 },
> - { 0x02, 0, 0, 0x00000001 },
> - { 0x30, 0, 0, 0x0000000e },
> - { 0x54, 0, 0, 0x0000000f },
> - { 0x64, 0, 0, 0x00000002 },
> - { 0x07, 0, 0, 0x00000005 },
> - { 0x60, 0, 0, 0x00000001 },
> - { 0x1c, 0, 0, 0x00000000 },
> - { 0x02, 0, 0, 0x00000005 },
> - { 0xb1, 0, 0, 0x0000000e },
> - { 0x50, 0, 0, 0x0000001a },
> - { 0x54, 0, 0, 0x000000f0 },
> - { 0x74, 0, 0, 0x00000002 },
> - { 0x07, 0, 0, 0x00000009 },
> - { 0x60, 0, 0, 0x00000005 },
> - { 0x1d, 4, 0, 0x00000000 },
> - { 0x80, 0, 0, 0x00000000 },
> - { 0x25, 1, 0, 0x00000073 },
> - { 0x35, 1, 0, 0xfc23ac00 },
> - { 0x06, 0, 0, 0x0000ffff },
> - { 0x06, 0, 0, 0x00000000 },
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
> + BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
> + BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
> + BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
> + BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
> + BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
> + BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
> + BPF_STMT(BPF_ST, 1),
> + BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
> + BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
> + BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
interesting observation. It means that libpcap doesn't init memory
properly and other fields just have junk in them?
and because it was doing it forever we need to accept such 'valid'
instructions? Oh well. ok.
Note to self: make sure to check for tidy instructions in eBPF verifier.
> + BPF_STMT(BPF_LD | BPF_MEM, 1),
> + BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
> + BPF_STMT(BPF_ST, 5),
> + BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
> + BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
> + BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
> + BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
> + BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
> + BPF_STMT(BPF_LD | BPF_MEM, 5),
> + BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
> + BPF_STMT(BPF_LD | BPF_LEN, 0),
> + BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
> + BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
> + BPF_STMT(BPF_RET | BPF_K, 0xffff),
> + BPF_STMT(BPF_RET | BPF_K, 0),
> },
> CLASSIC,
> { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
> @@ -1453,17 +1453,24 @@ static struct bpf_test tests[] = {
> BPF_STMT(BPF_RET | BPF_A, 0),
> },
> CLASSIC,
> - { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8, 0x90, 0xe2,
> - 0xba, 0x0a, 0x56, 0xb4, 0x08, 0x00, 0x45, 0x00,
> - 0x00, 0x28, 0x00, 0x00, 0x20, 0x00, 0x40, 0x11,
> - 0x00, 0x00, 0xc0, 0xa8, 0x33, 0x01, 0xc0, 0xa8,
> - 0x33, 0x02, 0xbb, 0xb6, 0xa9, 0xfa, 0x00, 0x14,
> - 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> - 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> - 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> - 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> - 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> - 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc },
> + { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
> + 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
> + 0x08, 0x00,
> + 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
> + 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
> + 0xc0, 0xa8, 0x33, 0x01,
> + 0xc0, 0xa8, 0x33, 0x02,
> + 0xbb, 0xb6,
> + 0xa9, 0xfa,
> + 0x00, 0x14, 0x00, 0x00,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
> + 0xcc, 0xcc, 0xcc, 0xcc },
> { { 88, 0x001b } }
> },
> {
> --
> 1.7.11.7
>
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs
2014-05-27 6:02 ` Alexei Starovoitov
@ 2014-05-27 16:57 ` Daniel Borkmann
0 siblings, 0 replies; 8+ messages in thread
From: Daniel Borkmann @ 2014-05-27 16:57 UTC (permalink / raw)
To: Alexei Starovoitov; +Cc: David S. Miller, Network Development
On 05/27/2014 08:02 AM, Alexei Starovoitov wrote:
...
> store and immediate load from the same slot won't catch slot overlap,
> but that would be a job for another test.
Have a test in my queue. ;)
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests
2014-05-27 6:20 ` Alexei Starovoitov
@ 2014-05-27 17:00 ` Daniel Borkmann
0 siblings, 0 replies; 8+ messages in thread
From: Daniel Borkmann @ 2014-05-27 17:00 UTC (permalink / raw)
To: Alexei Starovoitov; +Cc: David S. Miller, Network Development
On 05/27/2014 08:20 AM, Alexei Starovoitov wrote:
...
>> + BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
>> + BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
>
> interesting observation. It means that libpcap doesn't init memory
> properly and other fields just have junk in them?
> and because it was doing it forever we need to accept such 'valid'
> instructions? Oh well. ok.
Hmm, doesn't look like totally random. Perhaps they're
storing some intermediate value in it or something, and
don't clear that out as we have accepted that since ever,
but that shouldn't do anything anyway here. ;)
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH net-next 0/2] BPF test suite update
2014-05-26 18:17 [PATCH net-next 0/2] BPF test suite update Daniel Borkmann
2014-05-26 18:17 ` [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs Daniel Borkmann
2014-05-26 18:17 ` [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests Daniel Borkmann
@ 2014-05-30 23:27 ` David Miller
2 siblings, 0 replies; 8+ messages in thread
From: David Miller @ 2014-05-30 23:27 UTC (permalink / raw)
To: dborkman; +Cc: ast, netdev
From: Daniel Borkmann <dborkman@redhat.com>
Date: Mon, 26 May 2014 20:17:33 +0200
> Daniel Borkmann (2):
> net: filter: test fill/spill of all M[] regs
> net: filter: use block statements in tcpdump tests
Series applied, thanks.
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2014-05-30 23:27 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-05-26 18:17 [PATCH net-next 0/2] BPF test suite update Daniel Borkmann
2014-05-26 18:17 ` [PATCH net-next 1/2] net: filter: test fill/spill of all M[] regs Daniel Borkmann
2014-05-27 6:02 ` Alexei Starovoitov
2014-05-27 16:57 ` Daniel Borkmann
2014-05-26 18:17 ` [PATCH net-next 2/2] net: filter: use block statements in tcpdump tests Daniel Borkmann
2014-05-27 6:20 ` Alexei Starovoitov
2014-05-27 17:00 ` Daniel Borkmann
2014-05-30 23:27 ` [PATCH net-next 0/2] BPF test suite update David Miller
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).