From 92d1d5a44b51aaa50d2322c7f069ca52052613bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20Mei=C3=9Fner?= Date: Thu, 3 Oct 2024 16:38:35 +0200 Subject: [PATCH] Disables the old opcodes conditionally. --- src/disassembler.rs | 24 ++++++++++++------------ src/interpreter.rs | 24 ++++++++++++------------ src/jit.rs | 24 ++++++++++++------------ src/verifier.rs | 24 ++++++++++++------------ 4 files changed, 48 insertions(+), 48 deletions(-) diff --git a/src/disassembler.rs b/src/disassembler.rs index d93152042..da44c3437 100644 --- a/src/disassembler.rs +++ b/src/disassembler.rs @@ -124,22 +124,22 @@ pub fn disassemble_instruction( ebpf::LD_DW_IMM => { name = "lddw"; desc = format!("{} r{:}, {:#x}", name, insn.dst, insn.imm); }, // BPF_LDX class - ebpf::LD_B_REG => { name = "ldxb"; desc = ld_reg_str(name, insn); }, - ebpf::LD_H_REG => { name = "ldxh"; desc = ld_reg_str(name, insn); }, - ebpf::LD_W_REG => { name = "ldxw"; desc = ld_reg_str(name, insn); }, - ebpf::LD_DW_REG => { name = "ldxdw"; desc = ld_reg_str(name, insn); }, + ebpf::LD_B_REG if !sbpf_version.move_memory_instruction_classes() => { name = "ldxb"; desc = ld_reg_str(name, insn); }, + ebpf::LD_H_REG if !sbpf_version.move_memory_instruction_classes() => { name = "ldxh"; desc = ld_reg_str(name, insn); }, + ebpf::LD_W_REG if !sbpf_version.move_memory_instruction_classes() => { name = "ldxw"; desc = ld_reg_str(name, insn); }, + ebpf::LD_DW_REG if !sbpf_version.move_memory_instruction_classes() => { name = "ldxdw"; desc = ld_reg_str(name, insn); }, // BPF_ST class - ebpf::ST_B_IMM => { name = "stb"; desc = ld_st_imm_str(name, insn); }, - ebpf::ST_H_IMM => { name = "sth"; desc = ld_st_imm_str(name, insn); }, - ebpf::ST_W_IMM => { name = "stw"; desc = ld_st_imm_str(name, insn); }, - ebpf::ST_DW_IMM => { name = "stdw"; desc = ld_st_imm_str(name, insn); }, + ebpf::ST_B_IMM if !sbpf_version.move_memory_instruction_classes() => { name = "stb"; desc = ld_st_imm_str(name, insn); }, + ebpf::ST_H_IMM if !sbpf_version.move_memory_instruction_classes() => { name = "sth"; desc = ld_st_imm_str(name, insn); }, + ebpf::ST_W_IMM if !sbpf_version.move_memory_instruction_classes() => { name = "stw"; desc = ld_st_imm_str(name, insn); }, + ebpf::ST_DW_IMM if !sbpf_version.move_memory_instruction_classes() => { name = "stdw"; desc = ld_st_imm_str(name, insn); }, // BPF_STX class - ebpf::ST_B_REG => { name = "stxb"; desc = st_reg_str(name, insn); }, - ebpf::ST_H_REG => { name = "stxh"; desc = st_reg_str(name, insn); }, - ebpf::ST_W_REG => { name = "stxw"; desc = st_reg_str(name, insn); }, - ebpf::ST_DW_REG => { name = "stxdw"; desc = st_reg_str(name, insn); }, + ebpf::ST_B_REG if !sbpf_version.move_memory_instruction_classes() => { name = "stxb"; desc = st_reg_str(name, insn); }, + ebpf::ST_H_REG if !sbpf_version.move_memory_instruction_classes() => { name = "stxh"; desc = st_reg_str(name, insn); }, + ebpf::ST_W_REG if !sbpf_version.move_memory_instruction_classes() => { name = "stxw"; desc = st_reg_str(name, insn); }, + ebpf::ST_DW_REG if !sbpf_version.move_memory_instruction_classes() => { name = "stxdw"; desc = st_reg_str(name, insn); }, // BPF_ALU class ebpf::ADD32_IMM => { name = "add32"; desc = alu_imm_str(name, insn); }, diff --git a/src/interpreter.rs b/src/interpreter.rs index 8f3951e4f..eb11ad95d 100644 --- a/src/interpreter.rs +++ b/src/interpreter.rs @@ -194,55 +194,55 @@ impl<'a, 'b, C: ContextObject> Interpreter<'a, 'b, C> { }, // BPF_LDX class - ebpf::LD_B_REG => { + ebpf::LD_B_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[src] as i64).wrapping_add(insn.off as i64) as u64; self.reg[dst] = translate_memory_access!(self, load, vm_addr, u8); }, - ebpf::LD_H_REG => { + ebpf::LD_H_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[src] as i64).wrapping_add(insn.off as i64) as u64; self.reg[dst] = translate_memory_access!(self, load, vm_addr, u16); }, - ebpf::LD_W_REG => { + ebpf::LD_W_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[src] as i64).wrapping_add(insn.off as i64) as u64; self.reg[dst] = translate_memory_access!(self, load, vm_addr, u32); }, - ebpf::LD_DW_REG => { + ebpf::LD_DW_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[src] as i64).wrapping_add(insn.off as i64) as u64; self.reg[dst] = translate_memory_access!(self, load, vm_addr, u64); }, // BPF_ST class - ebpf::ST_B_IMM => { + ebpf::ST_B_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add( insn.off as i64) as u64; translate_memory_access!(self, store, insn.imm, vm_addr, u8); }, - ebpf::ST_H_IMM => { + ebpf::ST_H_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, insn.imm, vm_addr, u16); }, - ebpf::ST_W_IMM => { + ebpf::ST_W_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, insn.imm, vm_addr, u32); }, - ebpf::ST_DW_IMM => { + ebpf::ST_DW_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, insn.imm, vm_addr, u64); }, // BPF_STX class - ebpf::ST_B_REG => { + ebpf::ST_B_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, self.reg[src], vm_addr, u8); }, - ebpf::ST_H_REG => { + ebpf::ST_H_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, self.reg[src], vm_addr, u16); }, - ebpf::ST_W_REG => { + ebpf::ST_W_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, self.reg[src], vm_addr, u32); }, - ebpf::ST_DW_REG => { + ebpf::ST_DW_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { let vm_addr = (self.reg[dst] as i64).wrapping_add(insn.off as i64) as u64; translate_memory_access!(self, store, self.reg[src], vm_addr, u64); }, diff --git a/src/jit.rs b/src/jit.rs index 6616f7f8f..73328d623 100644 --- a/src/jit.rs +++ b/src/jit.rs @@ -439,44 +439,44 @@ impl<'a, C: ContextObject> JitCompiler<'a, C> { }, // BPF_LDX class - ebpf::LD_B_REG => { + ebpf::LD_B_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(Some(dst), Value::RegisterPlusConstant64(src, insn.off as i64, true), 1, None); }, - ebpf::LD_H_REG => { + ebpf::LD_H_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(Some(dst), Value::RegisterPlusConstant64(src, insn.off as i64, true), 2, None); }, - ebpf::LD_W_REG => { + ebpf::LD_W_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(Some(dst), Value::RegisterPlusConstant64(src, insn.off as i64, true), 4, None); }, - ebpf::LD_DW_REG => { + ebpf::LD_DW_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(Some(dst), Value::RegisterPlusConstant64(src, insn.off as i64, true), 8, None); }, // BPF_ST class - ebpf::ST_B_IMM => { + ebpf::ST_B_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 1, Some(Value::Constant64(insn.imm, true))); }, - ebpf::ST_H_IMM => { + ebpf::ST_H_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 2, Some(Value::Constant64(insn.imm, true))); }, - ebpf::ST_W_IMM => { + ebpf::ST_W_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 4, Some(Value::Constant64(insn.imm, true))); }, - ebpf::ST_DW_IMM => { + ebpf::ST_DW_IMM if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 8, Some(Value::Constant64(insn.imm, true))); }, // BPF_STX class - ebpf::ST_B_REG => { + ebpf::ST_B_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 1, Some(Value::Register(src))); }, - ebpf::ST_H_REG => { + ebpf::ST_H_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 2, Some(Value::Register(src))); }, - ebpf::ST_W_REG => { + ebpf::ST_W_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 4, Some(Value::Register(src))); }, - ebpf::ST_DW_REG => { + ebpf::ST_DW_REG if !self.executable.get_sbpf_version().move_memory_instruction_classes() => { self.emit_address_translation(None, Value::RegisterPlusConstant64(dst, insn.off as i64, true), 8, Some(Value::Register(src))); }, diff --git a/src/verifier.rs b/src/verifier.rs index 0e7b3504e..c82fad1dd 100644 --- a/src/verifier.rs +++ b/src/verifier.rs @@ -250,22 +250,22 @@ impl Verifier for RequisiteVerifier { }, // BPF_LDX class - ebpf::LD_B_REG => {}, - ebpf::LD_H_REG => {}, - ebpf::LD_W_REG => {}, - ebpf::LD_DW_REG => {}, + ebpf::LD_B_REG if !sbpf_version.move_memory_instruction_classes() => {}, + ebpf::LD_H_REG if !sbpf_version.move_memory_instruction_classes() => {}, + ebpf::LD_W_REG if !sbpf_version.move_memory_instruction_classes() => {}, + ebpf::LD_DW_REG if !sbpf_version.move_memory_instruction_classes() => {}, // BPF_ST class - ebpf::ST_B_IMM => store = true, - ebpf::ST_H_IMM => store = true, - ebpf::ST_W_IMM => store = true, - ebpf::ST_DW_IMM => store = true, + ebpf::ST_B_IMM if !sbpf_version.move_memory_instruction_classes() => store = true, + ebpf::ST_H_IMM if !sbpf_version.move_memory_instruction_classes() => store = true, + ebpf::ST_W_IMM if !sbpf_version.move_memory_instruction_classes() => store = true, + ebpf::ST_DW_IMM if !sbpf_version.move_memory_instruction_classes() => store = true, // BPF_STX class - ebpf::ST_B_REG => store = true, - ebpf::ST_H_REG => store = true, - ebpf::ST_W_REG => store = true, - ebpf::ST_DW_REG => store = true, + ebpf::ST_B_REG if !sbpf_version.move_memory_instruction_classes() => store = true, + ebpf::ST_H_REG if !sbpf_version.move_memory_instruction_classes() => store = true, + ebpf::ST_W_REG if !sbpf_version.move_memory_instruction_classes() => store = true, + ebpf::ST_DW_REG if !sbpf_version.move_memory_instruction_classes() => store = true, // BPF_ALU class ebpf::ADD32_IMM => {},