1 // SPDX-License-Identifier: GPL-2.0+ 2 3 #include <linux/bitops.h> 4 #include <linux/kernel.h> 5 #include <linux/kprobes.h> 6 7 #include "decode-insn.h" 8 #include "simulate-insn.h" 9 10 static inline bool rv_insn_reg_get_val(struct pt_regs *regs, u32 index, 11 unsigned long *ptr) 12 { 13 if (index == 0) 14 *ptr = 0; 15 else if (index <= 31) 16 *ptr = *((unsigned long *)regs + index); 17 else 18 return false; 19 20 return true; 21 } 22 23 static inline bool rv_insn_reg_set_val(struct pt_regs *regs, u32 index, 24 unsigned long val) 25 { 26 if (index == 0) 27 return true; 28 else if (index <= 31) 29 *((unsigned long *)regs + index) = val; 30 else 31 return false; 32 33 return true; 34 } 35 36 bool __kprobes simulate_jal(u32 opcode, unsigned long addr, struct pt_regs *regs) 37 { 38 /* 39 * 31 30 21 20 19 12 11 7 6 0 40 * imm [20] | imm[10:1] | imm[11] | imm[19:12] | rd | opcode 41 * 1 10 1 8 5 JAL/J 42 */ 43 bool ret; 44 s32 imm; 45 u32 index = RV_EXTRACT_RD_REG(opcode); 46 47 ret = rv_insn_reg_set_val(regs, index, addr + 4); 48 if (!ret) 49 return ret; 50 51 imm = RV_EXTRACT_JTYPE_IMM(opcode); 52 53 instruction_pointer_set(regs, addr + imm); 54 55 return ret; 56 } 57 58 bool __kprobes simulate_jalr(u32 opcode, unsigned long addr, struct pt_regs *regs) 59 { 60 /* 61 * 31 20 19 15 14 12 11 7 6 0 62 * offset[11:0] | rs1 | 010 | rd | opcode 63 * 12 5 3 5 JALR/JR 64 */ 65 bool ret; 66 unsigned long base_addr; 67 u32 imm = RV_EXTRACT_ITYPE_IMM(opcode); 68 u32 rd_index = RV_EXTRACT_RD_REG(opcode); 69 u32 rs1_index = RV_EXTRACT_RS1_REG(opcode); 70 71 ret = rv_insn_reg_get_val(regs, rs1_index, &base_addr); 72 if (!ret) 73 return ret; 74 75 ret = rv_insn_reg_set_val(regs, rd_index, addr + 4); 76 if (!ret) 77 return ret; 78 79 instruction_pointer_set(regs, (base_addr + sign_extend32((imm), 11))&~1); 80 81 return ret; 82 } 83 84 bool __kprobes simulate_auipc(u32 opcode, unsigned long addr, struct pt_regs *regs) 85 { 86 /* 87 * auipc instruction: 88 * 31 12 11 7 6 0 89 * | imm[31:12] | rd | opcode | 90 * 20 5 7 91 */ 92 93 u32 rd_idx = RV_EXTRACT_RD_REG(opcode); 94 unsigned long rd_val = addr + (s32)RV_EXTRACT_UTYPE_IMM(opcode); 95 96 if (!rv_insn_reg_set_val(regs, rd_idx, rd_val)) 97 return false; 98 99 instruction_pointer_set(regs, addr + 4); 100 101 return true; 102 } 103 104 bool __kprobes simulate_branch(u32 opcode, unsigned long addr, struct pt_regs *regs) 105 { 106 /* 107 * branch instructions: 108 * 31 30 25 24 20 19 15 14 12 11 8 7 6 0 109 * | imm[12] | imm[10:5] | rs2 | rs1 | funct3 | imm[4:1] | imm[11] | opcode | 110 * 1 6 5 5 3 4 1 7 111 * imm[12|10:5] rs2 rs1 000 imm[4:1|11] 1100011 BEQ 112 * imm[12|10:5] rs2 rs1 001 imm[4:1|11] 1100011 BNE 113 * imm[12|10:5] rs2 rs1 100 imm[4:1|11] 1100011 BLT 114 * imm[12|10:5] rs2 rs1 101 imm[4:1|11] 1100011 BGE 115 * imm[12|10:5] rs2 rs1 110 imm[4:1|11] 1100011 BLTU 116 * imm[12|10:5] rs2 rs1 111 imm[4:1|11] 1100011 BGEU 117 */ 118 119 s32 offset; 120 s32 offset_tmp; 121 unsigned long rs1_val; 122 unsigned long rs2_val; 123 124 if (!rv_insn_reg_get_val(regs, RV_EXTRACT_RS1_REG(opcode), &rs1_val) || 125 !rv_insn_reg_get_val(regs, RV_EXTRACT_RS2_REG(opcode), &rs2_val)) 126 return false; 127 128 offset_tmp = RV_EXTRACT_BTYPE_IMM(opcode); 129 switch (RV_EXTRACT_FUNCT3(opcode)) { 130 case RVG_FUNCT3_BEQ: 131 offset = (rs1_val == rs2_val) ? offset_tmp : 4; 132 break; 133 case RVG_FUNCT3_BNE: 134 offset = (rs1_val != rs2_val) ? offset_tmp : 4; 135 break; 136 case RVG_FUNCT3_BLT: 137 offset = ((long)rs1_val < (long)rs2_val) ? offset_tmp : 4; 138 break; 139 case RVG_FUNCT3_BGE: 140 offset = ((long)rs1_val >= (long)rs2_val) ? offset_tmp : 4; 141 break; 142 case RVG_FUNCT3_BLTU: 143 offset = (rs1_val < rs2_val) ? offset_tmp : 4; 144 break; 145 case RVG_FUNCT3_BGEU: 146 offset = (rs1_val >= rs2_val) ? offset_tmp : 4; 147 break; 148 default: 149 return false; 150 } 151 152 instruction_pointer_set(regs, addr + offset); 153 154 return true; 155 } 156 157 bool __kprobes simulate_c_j(u32 opcode, unsigned long addr, struct pt_regs *regs) 158 { 159 s32 offset = RVC_EXTRACT_JTYPE_IMM(opcode); 160 161 instruction_pointer_set(regs, addr + offset); 162 163 return true; 164 } 165 166 bool __kprobes simulate_c_jal(u32 opcode, unsigned long addr, struct pt_regs *regs) 167 { 168 regs->ra = addr + 2; 169 170 return simulate_c_j(opcode, addr, regs); 171 } 172 173 static bool __kprobes simulate_c_jr_jalr(u32 opcode, unsigned long addr, struct pt_regs *regs, 174 bool is_jalr) 175 { 176 /* 177 * 15 12 11 7 6 2 1 0 178 * | funct4 | rs1 | rs2 | op | 179 * 4 5 5 2 180 */ 181 182 unsigned long jump_addr; 183 184 u32 rs1 = RVC_EXTRACT_C2_RS1_REG(opcode); 185 186 if (rs1 == 0) /* C.JR is only valid when rs1 != x0 */ 187 return false; 188 189 if (!rv_insn_reg_get_val(regs, rs1, &jump_addr)) 190 return false; 191 192 if (is_jalr && !rv_insn_reg_set_val(regs, 1, addr + 2)) 193 return false; 194 195 instruction_pointer_set(regs, jump_addr); 196 197 return true; 198 } 199 200 bool __kprobes simulate_c_jr(u32 opcode, unsigned long addr, struct pt_regs *regs) 201 { 202 return simulate_c_jr_jalr(opcode, addr, regs, false); 203 } 204 205 bool __kprobes simulate_c_jalr(u32 opcode, unsigned long addr, struct pt_regs *regs) 206 { 207 return simulate_c_jr_jalr(opcode, addr, regs, true); 208 } 209 210 static bool __kprobes simulate_c_bnez_beqz(u32 opcode, unsigned long addr, struct pt_regs *regs, 211 bool is_bnez) 212 { 213 /* 214 * 15 13 12 10 9 7 6 2 1 0 215 * | funct3 | offset[8|4:3] | rs1' | offset[7:6|2:1|5] | op | 216 * 3 3 3 5 2 217 */ 218 219 s32 offset; 220 u32 rs1; 221 unsigned long rs1_val; 222 223 rs1 = 0x8 | ((opcode >> 7) & 0x7); 224 225 if (!rv_insn_reg_get_val(regs, rs1, &rs1_val)) 226 return false; 227 228 if ((rs1_val != 0 && is_bnez) || (rs1_val == 0 && !is_bnez)) 229 offset = RVC_EXTRACT_BTYPE_IMM(opcode); 230 else 231 offset = 2; 232 233 instruction_pointer_set(regs, addr + offset); 234 235 return true; 236 } 237 238 bool __kprobes simulate_c_bnez(u32 opcode, unsigned long addr, struct pt_regs *regs) 239 { 240 return simulate_c_bnez_beqz(opcode, addr, regs, true); 241 } 242 243 bool __kprobes simulate_c_beqz(u32 opcode, unsigned long addr, struct pt_regs *regs) 244 { 245 return simulate_c_bnez_beqz(opcode, addr, regs, false); 246 } 247