Vineet Gupta | c08098f | 2013-01-18 15:12:21 +0530 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com) |
| 3 | * |
| 4 | * This program is free software; you can redistribute it and/or modify |
| 5 | * it under the terms of the GNU General Public License version 2 as |
| 6 | * published by the Free Software Foundation. |
| 7 | */ |
| 8 | |
| 9 | #include <linux/ptrace.h> |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 10 | #include <linux/tracehook.h> |
Ingo Molnar | 68db0cf | 2017-02-08 18:51:37 +0100 | [diff] [blame] | 11 | #include <linux/sched/task_stack.h> |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 12 | #include <linux/regset.h> |
| 13 | #include <linux/unistd.h> |
| 14 | #include <linux/elf.h> |
| 15 | |
| 16 | static struct callee_regs *task_callee_regs(struct task_struct *tsk) |
| 17 | { |
| 18 | struct callee_regs *tmp = (struct callee_regs *)tsk->thread.callee_reg; |
| 19 | return tmp; |
| 20 | } |
| 21 | |
| 22 | static int genregs_get(struct task_struct *target, |
| 23 | const struct user_regset *regset, |
| 24 | unsigned int pos, unsigned int count, |
| 25 | void *kbuf, void __user *ubuf) |
| 26 | { |
| 27 | const struct pt_regs *ptregs = task_pt_regs(target); |
| 28 | const struct callee_regs *cregs = task_callee_regs(target); |
| 29 | int ret = 0; |
| 30 | unsigned int stop_pc_val; |
| 31 | |
| 32 | #define REG_O_CHUNK(START, END, PTR) \ |
| 33 | if (!ret) \ |
| 34 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, PTR, \ |
| 35 | offsetof(struct user_regs_struct, START), \ |
| 36 | offsetof(struct user_regs_struct, END)); |
| 37 | |
| 38 | #define REG_O_ONE(LOC, PTR) \ |
| 39 | if (!ret) \ |
| 40 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, PTR, \ |
| 41 | offsetof(struct user_regs_struct, LOC), \ |
| 42 | offsetof(struct user_regs_struct, LOC) + 4); |
| 43 | |
Vineet Gupta | 2fa9190 | 2013-05-28 09:43:17 +0530 | [diff] [blame] | 44 | #define REG_O_ZERO(LOC) \ |
| 45 | if (!ret) \ |
| 46 | ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, \ |
| 47 | offsetof(struct user_regs_struct, LOC), \ |
| 48 | offsetof(struct user_regs_struct, LOC) + 4); |
| 49 | |
| 50 | REG_O_ZERO(pad); |
Vineet Gupta | 6ffb9c8 | 2014-05-14 19:35:15 +0530 | [diff] [blame] | 51 | REG_O_ONE(scratch.bta, &ptregs->bta); |
| 52 | REG_O_ONE(scratch.lp_start, &ptregs->lp_start); |
| 53 | REG_O_ONE(scratch.lp_end, &ptregs->lp_end); |
| 54 | REG_O_ONE(scratch.lp_count, &ptregs->lp_count); |
| 55 | REG_O_ONE(scratch.status32, &ptregs->status32); |
| 56 | REG_O_ONE(scratch.ret, &ptregs->ret); |
| 57 | REG_O_ONE(scratch.blink, &ptregs->blink); |
| 58 | REG_O_ONE(scratch.fp, &ptregs->fp); |
| 59 | REG_O_ONE(scratch.gp, &ptregs->r26); |
| 60 | REG_O_ONE(scratch.r12, &ptregs->r12); |
| 61 | REG_O_ONE(scratch.r11, &ptregs->r11); |
| 62 | REG_O_ONE(scratch.r10, &ptregs->r10); |
| 63 | REG_O_ONE(scratch.r9, &ptregs->r9); |
| 64 | REG_O_ONE(scratch.r8, &ptregs->r8); |
| 65 | REG_O_ONE(scratch.r7, &ptregs->r7); |
| 66 | REG_O_ONE(scratch.r6, &ptregs->r6); |
| 67 | REG_O_ONE(scratch.r5, &ptregs->r5); |
| 68 | REG_O_ONE(scratch.r4, &ptregs->r4); |
| 69 | REG_O_ONE(scratch.r3, &ptregs->r3); |
| 70 | REG_O_ONE(scratch.r2, &ptregs->r2); |
| 71 | REG_O_ONE(scratch.r1, &ptregs->r1); |
| 72 | REG_O_ONE(scratch.r0, &ptregs->r0); |
| 73 | REG_O_ONE(scratch.sp, &ptregs->sp); |
| 74 | |
Vineet Gupta | 16f9afe | 2013-05-27 21:43:41 +0530 | [diff] [blame] | 75 | REG_O_ZERO(pad2); |
Vineet Gupta | 6ffb9c8 | 2014-05-14 19:35:15 +0530 | [diff] [blame] | 76 | |
| 77 | REG_O_ONE(callee.r25, &cregs->r25); |
| 78 | REG_O_ONE(callee.r24, &cregs->r24); |
| 79 | REG_O_ONE(callee.r23, &cregs->r23); |
| 80 | REG_O_ONE(callee.r22, &cregs->r22); |
| 81 | REG_O_ONE(callee.r21, &cregs->r21); |
| 82 | REG_O_ONE(callee.r20, &cregs->r20); |
| 83 | REG_O_ONE(callee.r19, &cregs->r19); |
| 84 | REG_O_ONE(callee.r18, &cregs->r18); |
| 85 | REG_O_ONE(callee.r17, &cregs->r17); |
| 86 | REG_O_ONE(callee.r16, &cregs->r16); |
| 87 | REG_O_ONE(callee.r15, &cregs->r15); |
| 88 | REG_O_ONE(callee.r14, &cregs->r14); |
| 89 | REG_O_ONE(callee.r13, &cregs->r13); |
| 90 | |
| 91 | REG_O_ONE(efa, &target->thread.fault_address); |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 92 | |
| 93 | if (!ret) { |
| 94 | if (in_brkpt_trap(ptregs)) { |
| 95 | stop_pc_val = target->thread.fault_address; |
| 96 | pr_debug("\t\tstop_pc (brk-pt)\n"); |
| 97 | } else { |
| 98 | stop_pc_val = ptregs->ret; |
| 99 | pr_debug("\t\tstop_pc (others)\n"); |
| 100 | } |
| 101 | |
| 102 | REG_O_ONE(stop_pc, &stop_pc_val); |
| 103 | } |
| 104 | |
| 105 | return ret; |
| 106 | } |
| 107 | |
| 108 | static int genregs_set(struct task_struct *target, |
| 109 | const struct user_regset *regset, |
| 110 | unsigned int pos, unsigned int count, |
| 111 | const void *kbuf, const void __user *ubuf) |
| 112 | { |
| 113 | const struct pt_regs *ptregs = task_pt_regs(target); |
| 114 | const struct callee_regs *cregs = task_callee_regs(target); |
| 115 | int ret = 0; |
| 116 | |
| 117 | #define REG_IN_CHUNK(FIRST, NEXT, PTR) \ |
| 118 | if (!ret) \ |
| 119 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, \ |
| 120 | (void *)(PTR), \ |
| 121 | offsetof(struct user_regs_struct, FIRST), \ |
| 122 | offsetof(struct user_regs_struct, NEXT)); |
| 123 | |
| 124 | #define REG_IN_ONE(LOC, PTR) \ |
| 125 | if (!ret) \ |
| 126 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, \ |
| 127 | (void *)(PTR), \ |
| 128 | offsetof(struct user_regs_struct, LOC), \ |
| 129 | offsetof(struct user_regs_struct, LOC) + 4); |
| 130 | |
| 131 | #define REG_IGNORE_ONE(LOC) \ |
| 132 | if (!ret) \ |
| 133 | ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, \ |
| 134 | offsetof(struct user_regs_struct, LOC), \ |
| 135 | offsetof(struct user_regs_struct, LOC) + 4); |
| 136 | |
Vineet Gupta | 2fa9190 | 2013-05-28 09:43:17 +0530 | [diff] [blame] | 137 | REG_IGNORE_ONE(pad); |
Vineet Gupta | 6ffb9c8 | 2014-05-14 19:35:15 +0530 | [diff] [blame] | 138 | |
| 139 | REG_IN_ONE(scratch.bta, &ptregs->bta); |
| 140 | REG_IN_ONE(scratch.lp_start, &ptregs->lp_start); |
| 141 | REG_IN_ONE(scratch.lp_end, &ptregs->lp_end); |
| 142 | REG_IN_ONE(scratch.lp_count, &ptregs->lp_count); |
| 143 | |
| 144 | REG_IGNORE_ONE(scratch.status32); |
| 145 | |
| 146 | REG_IN_ONE(scratch.ret, &ptregs->ret); |
| 147 | REG_IN_ONE(scratch.blink, &ptregs->blink); |
| 148 | REG_IN_ONE(scratch.fp, &ptregs->fp); |
| 149 | REG_IN_ONE(scratch.gp, &ptregs->r26); |
| 150 | REG_IN_ONE(scratch.r12, &ptregs->r12); |
| 151 | REG_IN_ONE(scratch.r11, &ptregs->r11); |
| 152 | REG_IN_ONE(scratch.r10, &ptregs->r10); |
| 153 | REG_IN_ONE(scratch.r9, &ptregs->r9); |
| 154 | REG_IN_ONE(scratch.r8, &ptregs->r8); |
| 155 | REG_IN_ONE(scratch.r7, &ptregs->r7); |
| 156 | REG_IN_ONE(scratch.r6, &ptregs->r6); |
| 157 | REG_IN_ONE(scratch.r5, &ptregs->r5); |
| 158 | REG_IN_ONE(scratch.r4, &ptregs->r4); |
| 159 | REG_IN_ONE(scratch.r3, &ptregs->r3); |
| 160 | REG_IN_ONE(scratch.r2, &ptregs->r2); |
| 161 | REG_IN_ONE(scratch.r1, &ptregs->r1); |
| 162 | REG_IN_ONE(scratch.r0, &ptregs->r0); |
| 163 | REG_IN_ONE(scratch.sp, &ptregs->sp); |
| 164 | |
Vineet Gupta | 16f9afe | 2013-05-27 21:43:41 +0530 | [diff] [blame] | 165 | REG_IGNORE_ONE(pad2); |
Vineet Gupta | 6ffb9c8 | 2014-05-14 19:35:15 +0530 | [diff] [blame] | 166 | |
| 167 | REG_IN_ONE(callee.r25, &cregs->r25); |
| 168 | REG_IN_ONE(callee.r24, &cregs->r24); |
| 169 | REG_IN_ONE(callee.r23, &cregs->r23); |
| 170 | REG_IN_ONE(callee.r22, &cregs->r22); |
| 171 | REG_IN_ONE(callee.r21, &cregs->r21); |
| 172 | REG_IN_ONE(callee.r20, &cregs->r20); |
| 173 | REG_IN_ONE(callee.r19, &cregs->r19); |
| 174 | REG_IN_ONE(callee.r18, &cregs->r18); |
| 175 | REG_IN_ONE(callee.r17, &cregs->r17); |
| 176 | REG_IN_ONE(callee.r16, &cregs->r16); |
| 177 | REG_IN_ONE(callee.r15, &cregs->r15); |
| 178 | REG_IN_ONE(callee.r14, &cregs->r14); |
| 179 | REG_IN_ONE(callee.r13, &cregs->r13); |
| 180 | |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 181 | REG_IGNORE_ONE(efa); /* efa update invalid */ |
Vineet Gupta | 6ffb9c8 | 2014-05-14 19:35:15 +0530 | [diff] [blame] | 182 | REG_IGNORE_ONE(stop_pc); /* PC updated via @ret */ |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 183 | |
| 184 | return ret; |
| 185 | } |
| 186 | |
| 187 | enum arc_getset { |
| 188 | REGSET_GENERAL, |
| 189 | }; |
| 190 | |
| 191 | static const struct user_regset arc_regsets[] = { |
| 192 | [REGSET_GENERAL] = { |
| 193 | .core_note_type = NT_PRSTATUS, |
| 194 | .n = ELF_NGREG, |
| 195 | .size = sizeof(unsigned long), |
| 196 | .align = sizeof(unsigned long), |
| 197 | .get = genregs_get, |
| 198 | .set = genregs_set, |
| 199 | } |
| 200 | }; |
| 201 | |
| 202 | static const struct user_regset_view user_arc_view = { |
| 203 | .name = UTS_MACHINE, |
Vineet Gupta | 1f6ccff | 2013-05-13 18:30:41 +0530 | [diff] [blame] | 204 | .e_machine = EM_ARC_INUSE, |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 205 | .regsets = arc_regsets, |
| 206 | .n = ARRAY_SIZE(arc_regsets) |
| 207 | }; |
| 208 | |
| 209 | const struct user_regset_view *task_user_regset_view(struct task_struct *task) |
| 210 | { |
| 211 | return &user_arc_view; |
| 212 | } |
Vineet Gupta | c08098f | 2013-01-18 15:12:21 +0530 | [diff] [blame] | 213 | |
| 214 | void ptrace_disable(struct task_struct *child) |
| 215 | { |
| 216 | } |
| 217 | |
| 218 | long arch_ptrace(struct task_struct *child, long request, |
| 219 | unsigned long addr, unsigned long data) |
| 220 | { |
| 221 | int ret = -EIO; |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 222 | |
| 223 | pr_debug("REQ=%ld: ADDR =0x%lx, DATA=0x%lx)\n", request, addr, data); |
| 224 | |
| 225 | switch (request) { |
Anton Kolesov | a4b6cb7 | 2014-06-20 20:28:39 +0400 | [diff] [blame] | 226 | case PTRACE_GET_THREAD_AREA: |
| 227 | ret = put_user(task_thread_info(child)->thr_ptr, |
| 228 | (unsigned long __user *)data); |
| 229 | break; |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 230 | default: |
| 231 | ret = ptrace_request(child, request, addr, data); |
| 232 | break; |
| 233 | } |
| 234 | |
Vineet Gupta | c08098f | 2013-01-18 15:12:21 +0530 | [diff] [blame] | 235 | return ret; |
| 236 | } |
| 237 | |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 238 | asmlinkage int syscall_trace_entry(struct pt_regs *regs) |
Vineet Gupta | c08098f | 2013-01-18 15:12:21 +0530 | [diff] [blame] | 239 | { |
Vineet Gupta | 547f112 | 2013-01-18 15:12:22 +0530 | [diff] [blame] | 240 | if (tracehook_report_syscall_entry(regs)) |
| 241 | return ULONG_MAX; |
| 242 | |
| 243 | return regs->r8; |
| 244 | } |
| 245 | |
| 246 | asmlinkage void syscall_trace_exit(struct pt_regs *regs) |
| 247 | { |
| 248 | tracehook_report_syscall_exit(regs, 0); |
Vineet Gupta | c08098f | 2013-01-18 15:12:21 +0530 | [diff] [blame] | 249 | } |