1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <linux/highmem.h> 3 #include <linux/ptrace.h> 4 #include <linux/sched.h> 5 #include <linux/uprobes.h> 6 #include <asm/cacheflush.h> 7 8 #define UPROBE_TRAP_NR UINT_MAX 9 10 int arch_uprobe_analyze_insn(struct arch_uprobe *auprobe, 11 struct mm_struct *mm, unsigned long addr) 12 { 13 int idx; 14 union loongarch_instruction insn; 15 16 if (addr & 0x3) 17 return -EILSEQ; 18 19 for (idx = ARRAY_SIZE(auprobe->insn) - 1; idx >= 0; idx--) { 20 insn.word = auprobe->insn[idx]; 21 if (insns_not_supported(insn)) 22 return -EINVAL; 23 } 24 25 if (insns_need_simulation(insn)) { 26 auprobe->ixol[0] = larch_insn_gen_nop(); 27 auprobe->simulate = true; 28 } else { 29 auprobe->ixol[0] = auprobe->insn[0]; 30 auprobe->simulate = false; 31 } 32 33 auprobe->ixol[1] = UPROBE_XOLBP_INSN; 34 35 return 0; 36 } 37 38 int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) 39 { 40 struct uprobe_task *utask = current->utask; 41 42 utask->autask.saved_trap_nr = current->thread.trap_nr; 43 current->thread.trap_nr = UPROBE_TRAP_NR; 44 instruction_pointer_set(regs, utask->xol_vaddr); 45 user_enable_single_step(current); 46 47 return 0; 48 } 49 50 int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) 51 { 52 struct uprobe_task *utask = current->utask; 53 54 WARN_ON_ONCE(current->thread.trap_nr != UPROBE_TRAP_NR); 55 current->thread.trap_nr = utask->autask.saved_trap_nr; 56 57 if (auprobe->simulate) 58 instruction_pointer_set(regs, auprobe->resume_era); 59 else 60 instruction_pointer_set(regs, utask->vaddr + LOONGARCH_INSN_SIZE); 61 62 user_disable_single_step(current); 63 64 return 0; 65 } 66 67 void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) 68 { 69 struct uprobe_task *utask = current->utask; 70 71 current->thread.trap_nr = utask->autask.saved_trap_nr; 72 instruction_pointer_set(regs, utask->vaddr); 73 user_disable_single_step(current); 74 } 75 76 bool arch_uprobe_xol_was_trapped(struct task_struct *t) 77 { 78 if (t->thread.trap_nr != UPROBE_TRAP_NR) 79 return true; 80 81 return false; 82 } 83 84 bool arch_uprobe_skip_sstep(struct arch_uprobe *auprobe, struct pt_regs *regs) 85 { 86 union loongarch_instruction insn; 87 88 if (!auprobe->simulate) 89 return false; 90 91 insn.word = auprobe->insn[0]; 92 arch_simulate_insn(insn, regs); 93 auprobe->resume_era = regs->csr_era; 94 95 return true; 96 } 97 98 unsigned long arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr, 99 struct pt_regs *regs) 100 { 101 unsigned long ra = regs->regs[1]; 102 103 regs->regs[1] = trampoline_vaddr; 104 105 return ra; 106 } 107 108 bool arch_uretprobe_is_alive(struct return_instance *ret, 109 enum rp_check ctx, struct pt_regs *regs) 110 { 111 if (ctx == RP_CHECK_CHAIN_CALL) 112 return regs->regs[3] <= ret->stack; 113 else 114 return regs->regs[3] < ret->stack; 115 } 116 117 int arch_uprobe_exception_notify(struct notifier_block *self, 118 unsigned long val, void *data) 119 { 120 return NOTIFY_DONE; 121 } 122 123 bool uprobe_breakpoint_handler(struct pt_regs *regs) 124 { 125 if (uprobe_pre_sstep_notifier(regs)) 126 return true; 127 128 return false; 129 } 130 131 bool uprobe_singlestep_handler(struct pt_regs *regs) 132 { 133 if (uprobe_post_sstep_notifier(regs)) 134 return true; 135 136 return false; 137 } 138 139 unsigned long uprobe_get_swbp_addr(struct pt_regs *regs) 140 { 141 return instruction_pointer(regs); 142 } 143 144 void arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr, 145 void *src, unsigned long len) 146 { 147 void *kaddr = kmap_local_page(page); 148 void *dst = kaddr + (vaddr & ~PAGE_MASK); 149 150 memcpy(dst, src, len); 151 flush_icache_range((unsigned long)dst, (unsigned long)dst + len); 152 kunmap_local(kaddr); 153 } 154