1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2014-2016 Pratyush Anand <panand@redhat.com> 4 */ 5 #include <linux/highmem.h> 6 #include <linux/ptrace.h> 7 #include <linux/uprobes.h> 8 #include <asm/cacheflush.h> 9 10 #include "decode-insn.h" 11 12 #define UPROBE_TRAP_NR UINT_MAX 13 14 unsigned long uprobe_get_swbp_addr(struct pt_regs *regs) 15 { 16 return instruction_pointer(regs); 17 } 18 19 int arch_uprobe_analyze_insn(struct arch_uprobe *auprobe, struct mm_struct *mm, 20 unsigned long addr) 21 { 22 probe_opcode_t insn; 23 24 insn = *(probe_opcode_t *)(&auprobe->insn[0]); 25 26 auprobe->insn_size = is_insn32(insn) ? 4 : 2; 27 28 switch (csky_probe_decode_insn(&insn, &auprobe->api)) { 29 case INSN_REJECTED: 30 return -EINVAL; 31 32 case INSN_GOOD_NO_SLOT: 33 auprobe->simulate = true; 34 break; 35 36 default: 37 break; 38 } 39 40 return 0; 41 } 42 43 int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) 44 { 45 struct uprobe_task *utask = current->utask; 46 47 utask->autask.saved_trap_no = current->thread.trap_no; 48 current->thread.trap_no = UPROBE_TRAP_NR; 49 50 instruction_pointer_set(regs, utask->xol_vaddr); 51 52 user_enable_single_step(current); 53 54 return 0; 55 } 56 57 int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) 58 { 59 struct uprobe_task *utask = current->utask; 60 61 WARN_ON_ONCE(current->thread.trap_no != UPROBE_TRAP_NR); 62 63 instruction_pointer_set(regs, utask->vaddr + auprobe->insn_size); 64 65 user_disable_single_step(current); 66 67 return 0; 68 } 69 70 bool arch_uprobe_xol_was_trapped(struct task_struct *t) 71 { 72 if (t->thread.trap_no != UPROBE_TRAP_NR) 73 return true; 74 75 return false; 76 } 77 78 bool arch_uprobe_skip_sstep(struct arch_uprobe *auprobe, struct pt_regs *regs) 79 { 80 probe_opcode_t insn; 81 unsigned long addr; 82 83 if (!auprobe->simulate) 84 return false; 85 86 insn = *(probe_opcode_t *)(&auprobe->insn[0]); 87 addr = instruction_pointer(regs); 88 89 if (auprobe->api.handler) 90 auprobe->api.handler(insn, addr, regs); 91 92 return true; 93 } 94 95 void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs) 96 { 97 struct uprobe_task *utask = current->utask; 98 99 /* 100 * Task has received a fatal signal, so reset back to probbed 101 * address. 102 */ 103 instruction_pointer_set(regs, utask->vaddr); 104 105 user_disable_single_step(current); 106 } 107 108 bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx, 109 struct pt_regs *regs) 110 { 111 if (ctx == RP_CHECK_CHAIN_CALL) 112 return regs->usp <= ret->stack; 113 else 114 return regs->usp < ret->stack; 115 } 116 117 unsigned long 118 arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr, 119 struct pt_regs *regs) 120 { 121 unsigned long ra; 122 123 ra = regs->lr; 124 125 regs->lr = trampoline_vaddr; 126 127 return ra; 128 } 129 130 int arch_uprobe_exception_notify(struct notifier_block *self, 131 unsigned long val, void *data) 132 { 133 return NOTIFY_DONE; 134 } 135 136 int uprobe_breakpoint_handler(struct pt_regs *regs) 137 { 138 if (uprobe_pre_sstep_notifier(regs)) 139 return 1; 140 141 return 0; 142 } 143 144 int uprobe_single_step_handler(struct pt_regs *regs) 145 { 146 if (uprobe_post_sstep_notifier(regs)) 147 return 1; 148 149 return 0; 150 } 151