Skip to contentSkip to conversation

bpf, riscv: clear target register high 32-bits for and/or/xor on ALU32

PATCH Applied Björn Töpel 2 participants 4 messages May 21, 2019 – May 23, 2019

Subsystems (6)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 bpf, riscv: clear target register high 32-bits for and/or/xor on ALU32

When using 32-bit subregisters (ALU32), the RISC-V JIT would not clear the high 32-bits of the target register and therefore generate incorrect code.

E.g., in the following code:

  $ cat test.c
  unsigned int f(unsigned long long a,
  	       unsigned int b)
  {
  	return (unsigned int)a & b;
  }
  $ clang-9 -target bpf -O2 -emit-llvm -S test.c -o - | \
  	llc-9 -mattr=+alu32 -mcpu=v3
  	.text
  	.file	"test.c"
  	.globl	f
  	.p2align	3
  	.type	f,@function
  f:
  	r0 = r1
  	w0 &= w2
  	exit
  .Lfunc_end0:
  	.size	f, .Lfunc_end0-f

The JIT would not clear the high 32-bits of r0 after the and-operation, which in this case might give an incorrect return value.

After this patch, that is not the case, and the upper 32-bits are cleared.

Fixes 2353ecc6f91f ("bpf, riscv: add BPF JIT for RV64G")
---
 arch/riscv/net/bpf_jit_comp.c | 6 ++++++
 1 file changed, 6 insertions(+)
arch/riscv/net/bpf_jit_comp.c +6 -0
index 80b12aa5e10d..e5c8d675bd6e 100644
@@ -759,14 +759,20 @@ static int emit_insn(const struct bpf_insn *insn, struct rv_jit_context *ctx,
 	case BPF_ALU | BPF_AND | BPF_X:
 	case BPF_ALU64 | BPF_AND | BPF_X:
 		emit(rv_and(rd, rd, rs), ctx);
+		if (!is64)
+			emit_zext_32(rd, ctx);
 		break;
 	case BPF_ALU | BPF_OR | BPF_X:
 	case BPF_ALU64 | BPF_OR | BPF_X:
 		emit(rv_or(rd, rd, rs), ctx);
+		if (!is64)
+			emit_zext_32(rd, ctx);
 		break;
 	case BPF_ALU | BPF_XOR | BPF_X:
 	case BPF_ALU64 | BPF_XOR | BPF_X:
 		emit(rv_xor(rd, rd, rs), ctx);
+		if (!is64)
+			emit_zext_32(rd, ctx);
 		break;
 	case BPF_ALU | BPF_MUL | BPF_X:
 	case BPF_ALU64 | BPF_MUL | BPF_X:
Signature · 1 line
2.20.1
maintainer
#1 lore raw
Quoted 31 lines · Björn Töpel

When using 32-bit subregisters (ALU32), the RISC-V JIT would not clear the high 32-bits of the target register and therefore generate incorrect code.

E.g., in the following code:

  $ cat test.c
  unsigned int f(unsigned long long a,
  	       unsigned int b)
  {
  	return (unsigned int)a & b;
  }
  $ clang-9 -target bpf -O2 -emit-llvm -S test.c -o - | \
  	llc-9 -mattr=+alu32 -mcpu=v3
  	.text
  	.file	"test.c"
  	.globl	f
  	.p2align	3
  	.type	f,@function
  f:
  	r0 = r1
  	w0 &= w2
  	exit
  .Lfunc_end0:
  	.size	f, .Lfunc_end0-f

The JIT would not clear the high 32-bits of r0 after the and-operation, which in this case might give an incorrect return value.

Quoted 6 lines

After this patch, that is not the case, and the upper 32-bits are cleared.

Fixes 2353ecc6f91f ("bpf, riscv: add BPF JIT for RV64G")

Was this missed because test_verifier did not have test coverage? If so, could you follow-up with alu32 test cases for it, so other JITs can be tracked for these kind of issue as well. We should probably have one for every alu32 alu op to make sure it's not forgotten anywhere.

Thanks,
Daniel

#2 lore raw
Quoted 33 lines · Daniel Borkmann
Quoted 31 lines · Björn Töpel

When using 32-bit subregisters (ALU32), the RISC-V JIT would not clear the high 32-bits of the target register and therefore generate incorrect code.

E.g., in the following code:

  $ cat test.c
  unsigned int f(unsigned long long a,
             unsigned int b)
  {
      return (unsigned int)a & b;
  }
  $ clang-9 -target bpf -O2 -emit-llvm -S test.c -o - | \
      llc-9 -mattr=+alu32 -mcpu=v3
      .text
      .file   "test.c"
      .globl  f
      .p2align        3
      .type   f,@function
  f:
      r0 = r1
      w0 &= w2
      exit
  .Lfunc_end0:
      .size   f, .Lfunc_end0-f

The JIT would not clear the high 32-bits of r0 after the and-operation, which in this case might give an incorrect return value.

Quoted 8 lines
Quoted 6 lines

After this patch, that is not the case, and the upper 32-bits are cleared.

Fixes 2353ecc6f91f ("bpf, riscv: add BPF JIT for RV64G")

Was this missed because test_verifier did not have test coverage?

Yup, and Jiong noted it.

Quoted 5 lines

If so, could you follow-up with alu32 test cases for it, so other JITs can be tracked for these kind of issue as well. We should probably have one for every alu32 alu op to make sure it's not forgotten anywhere.

I'll hack a test_verifier test right away.

Thanks,
Björn

Quoted 2 lines

Thanks,
Daniel

maintainer Applied
#3 lore raw
Quoted 36 lines · Björn Töpel
Quoted 35 lines · Daniel Borkmann
Quoted 34 lines · Björn Töpel

When using 32-bit subregisters (ALU32), the RISC-V JIT would not clear the high 32-bits of the target register and therefore generate incorrect code.

E.g., in the following code:

  $ cat test.c
  unsigned int f(unsigned long long a,
             unsigned int b)
  {
      return (unsigned int)a & b;
  }
  $ clang-9 -target bpf -O2 -emit-llvm -S test.c -o - | \
      llc-9 -mattr=+alu32 -mcpu=v3
      .text
      .file   "test.c"
      .globl  f
      .p2align        3
      .type   f,@function
  f:
      r0 = r1
      w0 &= w2
      exit
  .Lfunc_end0:
      .size   f, .Lfunc_end0-f

The JIT would not clear the high 32-bits of r0 after the and-operation, which in this case might give an incorrect return value.

After this patch, that is not the case, and the upper 32-bits are cleared.

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
Fixes 2353ecc6f91f ("bpf, riscv: add BPF JIT for RV64G")

Was this missed because test_verifier did not have test coverage?

Yup, and Jiong noted it.

Applied, thanks!