From: Johan Almbladh <johan.almbladh@anyfinetworks.com>
To: Alexei Starovoitov <ast@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
Andrii Nakryiko <andrii@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>, Song Liu <songliubraving@fb.com>,
Yonghong Song <yhs@fb.com>,
John Fastabend <john.fastabend@gmail.com>,
KP Singh <kpsingh@kernel.org>,
Networking <netdev@vger.kernel.org>, bpf <bpf@vger.kernel.org>,
Ilya Leoshkevich <iii@linux.ibm.com>
Subject: Re: [PATCH bpf-next 06/13] bpf/tests: Add staggered JMP and JMP32 tests
Date: Fri, 3 Sep 2021 10:22:23 +0200 [thread overview]
Message-ID: <CAM1=_QSpz_7T2CzUex0vfS7et7kzkFMxhr8yuzfYwUxKo_BKOw@mail.gmail.com> (raw)
In-Reply-To: <20210902185229.1840281-7-johan.almbladh@anyfinetworks.com>
On Thu, Sep 2, 2021 at 8:52 PM Johan Almbladh
<johan.almbladh@anyfinetworks.com> wrote:
>
> This patch adds a new type of jump test where the program jumps forwards
> and backwards with increasing offset. It mainly tests JITs where a
> relative jump may generate different JITed code depending on the offset
> size, read MIPS.
>
> Signed-off-by: Johan Almbladh <johan.almbladh@anyfinetworks.com>
> ---
> lib/test_bpf.c | 829 +++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 829 insertions(+)
>
> diff --git a/lib/test_bpf.c b/lib/test_bpf.c
> index 431f8d072f78..ea29e42418e3 100644
> --- a/lib/test_bpf.c
> +++ b/lib/test_bpf.c
> @@ -1478,6 +1478,426 @@ static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)
> return __bpf_fill_jmp32_reg(self, BPF_JSLE);
> }
>
> +/*
> + * Set up a sequence of staggered jumps, forwards and backwards with
> + * increasing offset. This tests the conversion of relative jumps to
> + * JITed native jumps. On some architectures, for example MIPS, a large
> + * PC-relative jump offset may overflow the immediate field of the native
> + * conditional branch instruction, triggering a conversion to use an
> + * absolute jump instead. Since this changes the jump offsets, another
> + * offset computation pass is necessary, and that may in turn trigger
> + * another branch conversion. This jump sequence is particularly nasty
> + * in that regard.
> + *
> + * The sequence generation is parameterized by size and jump type.
> + * The size must be even, and the expected result is always size + 1.
> + * Below is an example with size=8 and result=9.
> + *
> + * ________________________Start
> + * R0 = 0
> + * R1 = r1
> + * R2 = r2
> + * ,------- JMP +4 * 3______________Preamble: 4 insns
> + * ,----------|-ind 0- if R0 != 7 JMP 8 * 3 + 1 <--------------------.
> + * | | R0 = 8 |
> + * | ,--------|-----1- JMP +7 * 3 ------------------------.
> + * | | | if R0 != 5 JMP 7 * 3 + 1 <--------------. | |
> + * | | | R0 = 6 | | |
> + * | | ,------|-----2- JMP +5 * 3 ------------------. | |
> + * | | | | if R0 != 3 JMP 6 * 3 + 1 <--------. | | | |
> + * | | | | R0 = 4 | | | | |
> + * | | | ,----|-----3- JMP +3 * 3 ------------. | | | |
> + * | | | | | if R0 != 1 JMP 5 * 3 + 1 <--. | | | | | |
> + * | | | | | R0 = 2 | | | | | | |
> + * | | | | ,--|-----4- JMP +1 * 3 ------. | | | | | |
> + * | | | | | `------> if R0 != 0 JMP 4 * 3 + 1 1 2 3 4 5 6 7 8 loc
> + * | | | | | R0 = 1 -1 +2 -3 +4 -5 +6 -7 +8 off
> + * | | | | | ,------5- JMP -2 * 3 ---' | | | | | | |
> + * | | | | | | if R0 != 2 JMP 3 * 3 + 1 <-----' | | | | | |
> + * | | | | | | R0 = 3 | | | | | |
> + * | | | | | | JMP -4 * 3 ---------' | | | | |
> + * | | | | | | ,----6- if R0 != 4 JMP 2 * 3 + 1 <-----------' | | | |
> + * | | | | | | | R0 = 5 | | | |
> + * | | | | | | | JMP -6 * 3 ---------------' | | |
> + * | | | | | | | ,--7- if R0 != 6 JMP 1 * 3 + 1 <-----------------' | |
> + * | | | | | | | | R0 = 7 | |
> + * | | Error | | | JMP -8 * 3 ---------------------' |
> + * | | paths | | | ,8- if R0 != 8 JMP 0 * 3 + 1 <-----------------------'
> + * | | | | | | | | | R0 = 9__________________Sequence: 3 * size - 1 insns
> + * `-+-+-+-+-+-+-+-+-> EXIT____________________Return: 1 insn
> + *
> + */
I see that error path jumps at index 1-5 in this ASCII diagram is
drawn from the wrong instruction. They should start at the "if"
condition one step below. I will fix it.
> +
> +/* The maximum size parameter */
> +#define MAX_STAGGERED_JMP_SIZE ((0x7fff / 3) & ~1)
> +
> +/* We use a reduced number of iterations to get a reasonable execution time */
> +#define NR_STAGGERED_JMP_RUNS 10
> +
> +static int __bpf_fill_staggered_jumps(struct bpf_test *self,
> + const struct bpf_insn *jmp,
> + u64 r1, u64 r2)
> +{
> + int size = self->test[0].result - 1;
> + int len = 4 + 3 * (size + 1);
> + struct bpf_insn *insns;
> + int off, ind;
> +
> + insns = kmalloc_array(len, sizeof(*insns), GFP_KERNEL);
> + if (!insns)
> + return -ENOMEM;
> +
> + /* Preamble */
> + insns[0] = BPF_ALU64_IMM(BPF_MOV, R0, 0);
> + insns[1] = BPF_ALU64_IMM(BPF_MOV, R1, r1);
> + insns[2] = BPF_ALU64_IMM(BPF_MOV, R2, r2);
> + insns[3] = BPF_JMP_IMM(BPF_JA, 0, 0, 3 * size / 2);
> +
> + /* Sequence */
> + for (ind = 0, off = size; ind <= size; ind++, off -= 2) {
> + struct bpf_insn *ins = &insns[4 + 3 * ind];
> + int loc;
> +
> + if (off == 0)
> + off--;
> +
> + loc = abs(off);
> + ins[0] = BPF_JMP_IMM(BPF_JNE, R0, loc - 1,
> + 3 * (size - ind) + 1);
> + ins[1] = BPF_ALU64_IMM(BPF_MOV, R0, loc);
> + ins[2] = *jmp;
> + ins[2].off = 3 * (off - 1);
> + }
> +
> + /* Return */
> + insns[len - 1] = BPF_EXIT_INSN();
> +
> + self->u.ptr.insns = insns;
> + self->u.ptr.len = len;
> +
> + return 0;
> +}
> +
> +/* 64-bit unconditional jump */
> +static int bpf_fill_staggered_ja(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JA, 0, 0, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0, 0);
> +}
> +
> +/* 64-bit immediate jumps */
> +static int bpf_fill_staggered_jeq_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JEQ, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jne_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JNE, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
> +}
> +
> +static int bpf_fill_staggered_jset_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSET, R1, 0x82, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
> +}
> +
> +static int bpf_fill_staggered_jgt_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGT, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
> +}
> +
> +static int bpf_fill_staggered_jge_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JGE, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jlt_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLT, R1, 0x80000000, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jle_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JLE, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jsgt_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGT, R1, -2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
> +}
> +
> +static int bpf_fill_staggered_jsge_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSGE, R1, -2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
> +}
> +
> +static int bpf_fill_staggered_jslt_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLT, R1, -1, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
> +}
> +
> +static int bpf_fill_staggered_jsle_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_IMM(BPF_JSLE, R1, -1, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
> +}
> +
> +/* 64-bit register jumps */
> +static int bpf_fill_staggered_jeq_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JEQ, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
> +}
> +
> +static int bpf_fill_staggered_jne_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JNE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
> +}
> +
> +static int bpf_fill_staggered_jset_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JSET, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
> +}
> +
> +static int bpf_fill_staggered_jgt_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JGT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
> +}
> +
> +static int bpf_fill_staggered_jge_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JGE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
> +}
> +
> +static int bpf_fill_staggered_jlt_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JLT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
> +}
> +
> +static int bpf_fill_staggered_jle_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JLE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
> +}
> +
> +static int bpf_fill_staggered_jsgt_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
> +}
> +
> +static int bpf_fill_staggered_jsge_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JSGE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
> +}
> +
> +static int bpf_fill_staggered_jslt_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
> +}
> +
> +static int bpf_fill_staggered_jsle_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP_REG(BPF_JSLE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
> +}
> +
> +/* 32-bit immediate jumps */
> +static int bpf_fill_staggered_jeq32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JEQ, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jne32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JNE, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 4321, 0);
> +}
> +
> +static int bpf_fill_staggered_jset32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSET, R1, 0x82, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0);
> +}
> +
> +static int bpf_fill_staggered_jgt32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGT, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 0);
> +}
> +
> +static int bpf_fill_staggered_jge32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JGE, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jlt32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLT, R1, 0x80000000, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jle32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JLE, R1, 1234, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0);
> +}
> +
> +static int bpf_fill_staggered_jsgt32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGT, R1, -2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
> +}
> +
> +static int bpf_fill_staggered_jsge32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSGE, R1, -2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
> +}
> +
> +static int bpf_fill_staggered_jslt32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLT, R1, -1, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, 0);
> +}
> +
> +static int bpf_fill_staggered_jsle32_imm(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_IMM(BPF_JSLE, R1, -1, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, 0);
> +}
> +
> +/* 32-bit register jumps */
> +static int bpf_fill_staggered_jeq32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JEQ, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
> +}
> +
> +static int bpf_fill_staggered_jne32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JNE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 4321, 1234);
> +}
> +
> +static int bpf_fill_staggered_jset32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSET, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x86, 0x82);
> +}
> +
> +static int bpf_fill_staggered_jgt32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 0x80000000, 1234);
> +}
> +
> +static int bpf_fill_staggered_jge32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JGE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
> +}
> +
> +static int bpf_fill_staggered_jlt32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 0x80000000);
> +}
> +
> +static int bpf_fill_staggered_jle32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JLE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, 1234, 1234);
> +}
> +
> +static int bpf_fill_staggered_jsgt32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, -2);
> +}
> +
> +static int bpf_fill_staggered_jsge32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSGE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, -2);
> +}
> +
> +static int bpf_fill_staggered_jslt32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLT, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -2, -1);
> +}
> +
> +static int bpf_fill_staggered_jsle32_reg(struct bpf_test *self)
> +{
> + struct bpf_insn jmp = BPF_JMP32_REG(BPF_JSLE, R1, R2, 0);
> +
> + return __bpf_fill_staggered_jumps(self, &jmp, -1, -1);
> +}
> +
>
> static struct bpf_test tests[] = {
> {
> @@ -10222,6 +10642,415 @@ static struct bpf_test tests[] = {
> .fill_helper = bpf_fill_jmp32_jsle_reg,
> .nr_testruns = NR_PATTERN_RUNS,
> },
> + /* Staggered jump sequences, immediate */
> + {
> + "Staggered jumps: JMP_JA",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_ja,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JEQ_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jeq_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JNE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jne_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSET_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jset_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JGT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jgt_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JGE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jge_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JLT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jlt_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JLE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jle_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSGT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsgt_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSGE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsge_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSLT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jslt_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSLE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsle_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + /* Staggered jump sequences, register */
> + {
> + "Staggered jumps: JMP_JEQ_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jeq_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JNE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jne_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSET_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jset_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JGT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jgt_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JGE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jge_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JLT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jlt_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JLE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jle_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSGT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsgt_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSGE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsge_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSLT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jslt_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP_JSLE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsle_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + /* Staggered jump sequences, JMP32 immediate */
> + {
> + "Staggered jumps: JMP32_JEQ_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jeq32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JNE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jne32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSET_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jset32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JGT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jgt32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JGE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jge32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JLT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jlt32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JLE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jle32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSGT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsgt32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSGE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsge32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSLT_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jslt32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSLE_K",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsle32_imm,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + /* Staggered jump sequences, JMP32 register */
> + {
> + "Staggered jumps: JMP32_JEQ_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jeq32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JNE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jne32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSET_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jset32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JGT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jgt32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JGE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jge32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JLT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jlt32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JLE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jle32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSGT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsgt32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSGE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsge32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSLT_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jslt32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> + {
> + "Staggered jumps: JMP32_JSLE_X",
> + { },
> + INTERNAL | FLAG_NO_DATA,
> + { },
> + { { 0, MAX_STAGGERED_JMP_SIZE + 1 } },
> + .fill_helper = bpf_fill_staggered_jsle32_reg,
> + .nr_testruns = NR_STAGGERED_JMP_RUNS,
> + },
> };
>
> static struct net_device dev;
> --
> 2.25.1
>
next prev parent reply other threads:[~2021-09-03 8:21 UTC|newest]
Thread overview: 17+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-09-02 18:52 [PATCH bpf-next 00/13] bpf/tests: Extend JIT test suite coverage Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 01/13] bpf/tests: Allow different number of runs per test case Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 02/13] bpf/tests: Reduce memory footprint of test suite Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 03/13] bpf/tests: Add exhaustive tests of ALU shift values Johan Almbladh
2021-09-03 6:39 ` kernel test robot
2021-09-03 6:39 ` kernel test robot
2021-09-02 18:52 ` [PATCH bpf-next 04/13] bpf/tests: Add exhaustive tests of ALU operand magnitudes Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 05/13] bpf/tests: Add exhaustive tests of JMP " Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 06/13] bpf/tests: Add staggered JMP and JMP32 tests Johan Almbladh
2021-09-03 8:22 ` Johan Almbladh [this message]
2021-09-02 18:52 ` [PATCH bpf-next 07/13] bpf/tests: Add exhaustive test of LD_IMM64 immediate magnitudes Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 08/13] bpf/tests: Add test case flag for verifier zero-extension Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 09/13] bpf/tests: Add JMP tests with small offsets Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 10/13] bpf/tests: Add JMP tests with degenerate conditional Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 11/13] bpf/tests: Expand branch conversion JIT test Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 12/13] bpf/tests: Add more BPF_END byte order conversion tests Johan Almbladh
2021-09-02 18:52 ` [PATCH bpf-next 13/13] bpf/tests: Add tail call limit test with external function call Johan Almbladh
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to='CAM1=_QSpz_7T2CzUex0vfS7et7kzkFMxhr8yuzfYwUxKo_BKOw@mail.gmail.com' \
--to=johan.almbladh@anyfinetworks.com \
--cc=andrii@kernel.org \
--cc=ast@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=iii@linux.ibm.com \
--cc=john.fastabend@gmail.com \
--cc=kafai@fb.com \
--cc=kpsingh@kernel.org \
--cc=netdev@vger.kernel.org \
--cc=songliubraving@fb.com \
--cc=yhs@fb.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.