Skip to content

Commit 860612f

Browse files
Xu KuohaiNobody
Xu Kuohai
authored and
Nobody
committed
bpf/tests: Add tests for BPF_LDX/BPF_STX with different offsets
This patch adds tests to verify the behavior of BPF_LDX/BPF_STX + BPF_B/BPF_H/BPF_W/BPF_DW with negative offset, small positive offset, large positive offset, and misaligned offset. Tested on both big-endian and little-endian arm64 qemu, result: test_bpf: Summary: 1026 PASSED, 0 FAILED, [1014/1014 JIT'ed] test_bpf: test_tail_calls: Summary: 8 PASSED, 0 FAILED, [8/8 JIT'ed] test_bpf: test_skb_segment: Summary: 2 PASSED, 0 FAILED Signed-off-by: Xu Kuohai <[email protected]>
1 parent 088f0b2 commit 860612f

File tree

1 file changed

+281
-4
lines changed

1 file changed

+281
-4
lines changed

‎lib/test_bpf.c

Lines changed: 281 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@
5353
#define FLAG_EXPECTED_FAIL BIT(1)
5454
#define FLAG_SKB_FRAG BIT(2)
5555
#define FLAG_VERIFIER_ZEXT BIT(3)
56+
#define FLAG_LARGE_MEM BIT(4)
5657

5758
enum {
5859
CLASSIC = BIT(6), /* Old BPF instructions only. */
@@ -7838,7 +7839,7 @@ static struct bpf_test tests[] = {
78387839
},
78397840
/* BPF_LDX_MEM B/H/W/DW */
78407841
{
7841-
"BPF_LDX_MEM | BPF_B",
7842+
"BPF_LDX_MEM | BPF_B, base",
78427843
.u.insns_int = {
78437844
BPF_LD_IMM64(R1, 0x0102030405060708ULL),
78447845
BPF_LD_IMM64(R2, 0x0000000000000008ULL),
@@ -7878,7 +7879,56 @@ static struct bpf_test tests[] = {
78787879
.stack_depth = 8,
78797880
},
78807881
{
7881-
"BPF_LDX_MEM | BPF_H",
7882+
"BPF_LDX_MEM | BPF_B, negative offset",
7883+
.u.insns_int = {
7884+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7885+
BPF_LD_IMM64(R3, 0x0000000000000088ULL),
7886+
BPF_ALU64_IMM(BPF_ADD, R1, 512),
7887+
BPF_STX_MEM(BPF_B, R1, R2, -256),
7888+
BPF_LDX_MEM(BPF_B, R0, R1, -256),
7889+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7890+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
7891+
BPF_EXIT_INSN(),
7892+
},
7893+
INTERNAL | FLAG_LARGE_MEM,
7894+
{ },
7895+
{ { 512, 0 } },
7896+
.stack_depth = 0,
7897+
},
7898+
{
7899+
"BPF_LDX_MEM | BPF_B, small positive offset",
7900+
.u.insns_int = {
7901+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7902+
BPF_LD_IMM64(R3, 0x0000000000000088ULL),
7903+
BPF_STX_MEM(BPF_B, R1, R2, 256),
7904+
BPF_LDX_MEM(BPF_B, R0, R1, 256),
7905+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7906+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
7907+
BPF_EXIT_INSN(),
7908+
},
7909+
INTERNAL | FLAG_LARGE_MEM,
7910+
{ },
7911+
{ { 512, 0 } },
7912+
.stack_depth = 0,
7913+
},
7914+
{
7915+
"BPF_LDX_MEM | BPF_B, large positive offset",
7916+
.u.insns_int = {
7917+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7918+
BPF_LD_IMM64(R3, 0x0000000000000088ULL),
7919+
BPF_STX_MEM(BPF_B, R1, R2, 4096),
7920+
BPF_LDX_MEM(BPF_B, R0, R1, 4096),
7921+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7922+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
7923+
BPF_EXIT_INSN(),
7924+
},
7925+
INTERNAL | FLAG_LARGE_MEM,
7926+
{ },
7927+
{ { 4096 + 16, 0 } },
7928+
.stack_depth = 0,
7929+
},
7930+
{
7931+
"BPF_LDX_MEM | BPF_H, base",
78827932
.u.insns_int = {
78837933
BPF_LD_IMM64(R1, 0x0102030405060708ULL),
78847934
BPF_LD_IMM64(R2, 0x0000000000000708ULL),
@@ -7918,7 +7968,72 @@ static struct bpf_test tests[] = {
79187968
.stack_depth = 8,
79197969
},
79207970
{
7921-
"BPF_LDX_MEM | BPF_W",
7971+
"BPF_LDX_MEM | BPF_H, negative offset",
7972+
.u.insns_int = {
7973+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7974+
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
7975+
BPF_ALU64_IMM(BPF_ADD, R1, 512),
7976+
BPF_STX_MEM(BPF_H, R1, R2, -256),
7977+
BPF_LDX_MEM(BPF_H, R0, R1, -256),
7978+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7979+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
7980+
BPF_EXIT_INSN(),
7981+
},
7982+
INTERNAL | FLAG_LARGE_MEM,
7983+
{ },
7984+
{ { 512, 0 } },
7985+
.stack_depth = 0,
7986+
},
7987+
{
7988+
"BPF_LDX_MEM | BPF_H, small positive offset",
7989+
.u.insns_int = {
7990+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
7991+
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
7992+
BPF_STX_MEM(BPF_H, R1, R2, 256),
7993+
BPF_LDX_MEM(BPF_H, R0, R1, 256),
7994+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
7995+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
7996+
BPF_EXIT_INSN(),
7997+
},
7998+
INTERNAL | FLAG_LARGE_MEM,
7999+
{ },
8000+
{ { 512, 0 } },
8001+
.stack_depth = 0,
8002+
},
8003+
{
8004+
"BPF_LDX_MEM | BPF_H, large positive offset",
8005+
.u.insns_int = {
8006+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8007+
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8008+
BPF_STX_MEM(BPF_H, R1, R2, 8192),
8009+
BPF_LDX_MEM(BPF_H, R0, R1, 8192),
8010+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8011+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8012+
BPF_EXIT_INSN(),
8013+
},
8014+
INTERNAL | FLAG_LARGE_MEM,
8015+
{ },
8016+
{ { 8192 + 16, 0 } },
8017+
.stack_depth = 0,
8018+
},
8019+
{
8020+
"BPF_LDX_MEM | BPF_H, misaligned offset",
8021+
.u.insns_int = {
8022+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8023+
BPF_LD_IMM64(R3, 0x0000000000008788ULL),
8024+
BPF_STX_MEM(BPF_H, R1, R2, 13),
8025+
BPF_LDX_MEM(BPF_H, R0, R1, 13),
8026+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8027+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8028+
BPF_EXIT_INSN(),
8029+
},
8030+
INTERNAL | FLAG_LARGE_MEM,
8031+
{ },
8032+
{ { 32, 0 } },
8033+
.stack_depth = 0,
8034+
},
8035+
{
8036+
"BPF_LDX_MEM | BPF_W, base",
79228037
.u.insns_int = {
79238038
BPF_LD_IMM64(R1, 0x0102030405060708ULL),
79248039
BPF_LD_IMM64(R2, 0x0000000005060708ULL),
@@ -7957,6 +8072,162 @@ static struct bpf_test tests[] = {
79578072
{ { 0, 0 } },
79588073
.stack_depth = 8,
79598074
},
8075+
{
8076+
"BPF_LDX_MEM | BPF_W, negative offset",
8077+
.u.insns_int = {
8078+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8079+
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8080+
BPF_ALU64_IMM(BPF_ADD, R1, 512),
8081+
BPF_STX_MEM(BPF_W, R1, R2, -256),
8082+
BPF_LDX_MEM(BPF_W, R0, R1, -256),
8083+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8084+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8085+
BPF_EXIT_INSN(),
8086+
},
8087+
INTERNAL | FLAG_LARGE_MEM,
8088+
{ },
8089+
{ { 512, 0 } },
8090+
.stack_depth = 0,
8091+
},
8092+
{
8093+
"BPF_LDX_MEM | BPF_W, small positive offset",
8094+
.u.insns_int = {
8095+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8096+
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8097+
BPF_STX_MEM(BPF_W, R1, R2, 256),
8098+
BPF_LDX_MEM(BPF_W, R0, R1, 256),
8099+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8100+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8101+
BPF_EXIT_INSN(),
8102+
},
8103+
INTERNAL | FLAG_LARGE_MEM,
8104+
{ },
8105+
{ { 512, 0 } },
8106+
.stack_depth = 0,
8107+
},
8108+
{
8109+
"BPF_LDX_MEM | BPF_W, large positive offset",
8110+
.u.insns_int = {
8111+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8112+
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8113+
BPF_STX_MEM(BPF_W, R1, R2, 16384),
8114+
BPF_LDX_MEM(BPF_W, R0, R1, 16384),
8115+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8116+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8117+
BPF_EXIT_INSN(),
8118+
},
8119+
INTERNAL | FLAG_LARGE_MEM,
8120+
{ },
8121+
{ { 16384 + 16, 0 } },
8122+
.stack_depth = 0,
8123+
},
8124+
{
8125+
"BPF_LDX_MEM | BPF_W, misaligned positive offset",
8126+
.u.insns_int = {
8127+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8128+
BPF_LD_IMM64(R3, 0x0000000085868788ULL),
8129+
BPF_STX_MEM(BPF_W, R1, R2, 13),
8130+
BPF_LDX_MEM(BPF_W, R0, R1, 13),
8131+
BPF_JMP_REG(BPF_JNE, R0, R3, 1),
8132+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8133+
BPF_EXIT_INSN(),
8134+
},
8135+
INTERNAL | FLAG_LARGE_MEM,
8136+
{ },
8137+
{ { 32, 0 } },
8138+
.stack_depth = 0,
8139+
},
8140+
{
8141+
"BPF_LDX_MEM | BPF_DW, base",
8142+
.u.insns_int = {
8143+
BPF_LD_IMM64(R1, 0x0102030405060708ULL),
8144+
BPF_STX_MEM(BPF_DW, R10, R1, -8),
8145+
BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8146+
BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8147+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8148+
BPF_EXIT_INSN(),
8149+
},
8150+
INTERNAL,
8151+
{ },
8152+
{ { 0, 0 } },
8153+
.stack_depth = 8,
8154+
},
8155+
{
8156+
"BPF_LDX_MEM | BPF_DW, MSB set",
8157+
.u.insns_int = {
8158+
BPF_LD_IMM64(R1, 0x8182838485868788ULL),
8159+
BPF_STX_MEM(BPF_DW, R10, R1, -8),
8160+
BPF_LDX_MEM(BPF_DW, R0, R10, -8),
8161+
BPF_JMP_REG(BPF_JNE, R0, R1, 1),
8162+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8163+
BPF_EXIT_INSN(),
8164+
},
8165+
INTERNAL,
8166+
{ },
8167+
{ { 0, 0 } },
8168+
.stack_depth = 8,
8169+
},
8170+
{
8171+
"BPF_LDX_MEM | BPF_DW, negative offset",
8172+
.u.insns_int = {
8173+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8174+
BPF_ALU64_IMM(BPF_ADD, R1, 512),
8175+
BPF_STX_MEM(BPF_DW, R1, R2, -256),
8176+
BPF_LDX_MEM(BPF_DW, R0, R1, -256),
8177+
BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8178+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8179+
BPF_EXIT_INSN(),
8180+
},
8181+
INTERNAL | FLAG_LARGE_MEM,
8182+
{ },
8183+
{ { 512, 0 } },
8184+
.stack_depth = 0,
8185+
},
8186+
{
8187+
"BPF_LDX_MEM | BPF_DW, small positive offset",
8188+
.u.insns_int = {
8189+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8190+
BPF_STX_MEM(BPF_DW, R1, R2, 256),
8191+
BPF_LDX_MEM(BPF_DW, R0, R1, 256),
8192+
BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8193+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8194+
BPF_EXIT_INSN(),
8195+
},
8196+
INTERNAL | FLAG_LARGE_MEM,
8197+
{ },
8198+
{ { 512, 0 } },
8199+
.stack_depth = 8,
8200+
},
8201+
{
8202+
"BPF_LDX_MEM | BPF_DW, large positive offset",
8203+
.u.insns_int = {
8204+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8205+
BPF_STX_MEM(BPF_DW, R1, R2, 32768),
8206+
BPF_LDX_MEM(BPF_DW, R0, R1, 32768),
8207+
BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8208+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8209+
BPF_EXIT_INSN(),
8210+
},
8211+
INTERNAL | FLAG_LARGE_MEM,
8212+
{ },
8213+
{ { 32768 + 16, 0 } },
8214+
.stack_depth = 0,
8215+
},
8216+
{
8217+
"BPF_LDX_MEM | BPF_DW, misaligned positive offset",
8218+
.u.insns_int = {
8219+
BPF_LD_IMM64(R2, 0x8182838485868788ULL),
8220+
BPF_STX_MEM(BPF_DW, R1, R2, 13),
8221+
BPF_LDX_MEM(BPF_DW, R0, R1, 13),
8222+
BPF_JMP_REG(BPF_JNE, R0, R2, 1),
8223+
BPF_ALU64_IMM(BPF_MOV, R0, 0),
8224+
BPF_EXIT_INSN(),
8225+
},
8226+
INTERNAL | FLAG_LARGE_MEM,
8227+
{ },
8228+
{ { 32, 0 } },
8229+
.stack_depth = 0,
8230+
},
79608231
/* BPF_STX_MEM B/H/W/DW */
79618232
{
79628233
"BPF_STX_MEM | BPF_B",
@@ -14094,6 +14365,9 @@ static void *generate_test_data(struct bpf_test *test, int sub)
1409414365
if (test->aux & FLAG_NO_DATA)
1409514366
return NULL;
1409614367

14368+
if (test->aux & FLAG_LARGE_MEM)
14369+
return kmalloc(test->test[sub].data_size, GFP_KERNEL);
14370+
1409714371
/* Test case expects an skb, so populate one. Various
1409814372
* subtests generate skbs of different sizes based on
1409914373
* the same data.
@@ -14137,7 +14411,10 @@ static void release_test_data(const struct bpf_test *test, void *data)
1413714411
if (test->aux & FLAG_NO_DATA)
1413814412
return;
1413914413

14140-
kfree_skb(data);
14414+
if (test->aux & FLAG_LARGE_MEM)
14415+
kfree(data);
14416+
else
14417+
kfree_skb(data);
1414114418
}
1414214419

1414314420
static int filter_length(int which)

0 commit comments

Comments
 (0)