2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
14 * Copied from i386: Ross Biro 1/23/92
17 #include <linux/kernel.h>
18 #include <linux/ptrace.h>
19 #include <linux/kprobes.h>
20 #include <linux/compat.h>
21 #include <linux/uaccess.h>
22 #include <linux/regset.h>
23 #include <linux/elf.h>
24 #include <linux/tracehook.h>
25 #include <linux/context_tracking.h>
26 #include <asm/traps.h>
27 #include <arch/chip.h>
29 #define CREATE_TRACE_POINTS
30 #include <trace/events/syscalls.h>
32 void user_enable_single_step(struct task_struct *child)
34 set_tsk_thread_flag(child, TIF_SINGLESTEP);
37 void user_disable_single_step(struct task_struct *child)
39 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
43 * Called by kernel/ptrace.c when detaching..
45 void ptrace_disable(struct task_struct *child)
47 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
50 * These two are currently unused, but will be set by arch_ptrace()
51 * and used in the syscall assembly when we do support them.
53 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
57 * Get registers from task and ready the result for userspace.
58 * Note that we localize the API issues to getregs() and putregs() at
59 * some cost in performance, e.g. we need a full pt_regs copy for
60 * PEEKUSR, and two copies for POKEUSR. But in general we expect
61 * GETREGS/PUTREGS to be the API of choice anyway.
63 static char *getregs(struct task_struct *child, struct pt_regs *uregs)
65 *uregs = *task_pt_regs(child);
67 /* Set up flags ABI bits. */
70 if (task_thread_info(child)->status & TS_COMPAT)
71 uregs->flags |= PT_FLAGS_COMPAT;
77 /* Put registers back to task. */
78 static void putregs(struct task_struct *child, struct pt_regs *uregs)
80 struct pt_regs *regs = task_pt_regs(child);
82 /* Don't allow overwriting the kernel-internal flags word. */
83 uregs->flags = regs->flags;
85 /* Only allow setting the ICS bit in the ex1 word. */
86 uregs->ex1 = PL_ICS_EX1(USER_PL, EX1_ICS(uregs->ex1));
95 static int tile_gpr_get(struct task_struct *target,
96 const struct user_regset *regset,
97 unsigned int pos, unsigned int count,
98 void *kbuf, void __user *ubuf)
102 getregs(target, ®s);
104 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s, 0,
108 static int tile_gpr_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)
116 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, ®s, 0,
121 putregs(target, ®s);
126 static const struct user_regset tile_user_regset[] = {
128 .core_note_type = NT_PRSTATUS,
130 .size = sizeof(elf_greg_t),
131 .align = sizeof(elf_greg_t),
137 static const struct user_regset_view tile_user_regset_view = {
138 .name = CHIP_ARCH_NAME,
139 .e_machine = ELF_ARCH,
140 .ei_osabi = ELF_OSABI,
141 .regsets = tile_user_regset,
142 .n = ARRAY_SIZE(tile_user_regset),
145 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
147 return &tile_user_regset_view;
150 long arch_ptrace(struct task_struct *child, long request,
151 unsigned long addr, unsigned long data)
153 unsigned long __user *datap = (long __user __force *)data;
157 struct pt_regs copyregs;
161 case PTRACE_PEEKUSR: /* Read register from pt_regs. */
162 if (addr >= PTREGS_SIZE)
164 childreg = getregs(child, ©regs) + addr;
166 if (is_compat_task()) {
167 if (addr & (sizeof(compat_long_t)-1))
169 ret = put_user(*(compat_long_t *)childreg,
170 (compat_long_t __user *)datap);
174 if (addr & (sizeof(long)-1))
176 ret = put_user(*(long *)childreg, datap);
180 case PTRACE_POKEUSR: /* Write register in pt_regs. */
181 if (addr >= PTREGS_SIZE)
183 childreg = getregs(child, ©regs) + addr;
185 if (is_compat_task()) {
186 if (addr & (sizeof(compat_long_t)-1))
188 *(compat_long_t *)childreg = data;
192 if (addr & (sizeof(long)-1))
194 *(long *)childreg = data;
196 putregs(child, ©regs);
200 case PTRACE_GETREGS: /* Get all registers from the child. */
201 ret = copy_regset_to_user(child, &tile_user_regset_view,
203 sizeof(struct pt_regs), datap);
206 case PTRACE_SETREGS: /* Set all registers in the child. */
207 ret = copy_regset_from_user(child, &tile_user_regset_view,
209 sizeof(struct pt_regs), datap);
212 case PTRACE_GETFPREGS: /* Get the child FPU state. */
213 case PTRACE_SETFPREGS: /* Set the child FPU state. */
216 case PTRACE_SETOPTIONS:
217 /* Support TILE-specific ptrace options. */
218 BUILD_BUG_ON(PTRACE_O_MASK_TILE & PTRACE_O_MASK);
219 tmp = data & PTRACE_O_MASK_TILE;
220 data &= ~PTRACE_O_MASK_TILE;
221 ret = ptrace_request(child, request, addr, data);
223 unsigned int flags = child->ptrace;
224 flags &= ~(PTRACE_O_MASK_TILE << PT_OPT_FLAG_SHIFT);
225 flags |= (tmp << PT_OPT_FLAG_SHIFT);
226 child->ptrace = flags;
232 if (task_thread_info(current)->status & TS_COMPAT) {
233 ret = compat_ptrace_request(child, request,
238 ret = ptrace_request(child, request, addr, data);
246 /* Not used; we handle compat issues in arch_ptrace() directly. */
247 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
248 compat_ulong_t addr, compat_ulong_t data)
254 int do_syscall_trace_enter(struct pt_regs *regs)
256 u32 work = ACCESS_ONCE(current_thread_info()->flags);
258 if ((work & _TIF_SYSCALL_TRACE) &&
259 tracehook_report_syscall_entry(regs)) {
260 regs->regs[TREG_SYSCALL_NR] = -1;
264 if (secure_computing(NULL) == -1)
267 if (work & _TIF_SYSCALL_TRACEPOINT)
268 trace_sys_enter(regs, regs->regs[TREG_SYSCALL_NR]);
270 return regs->regs[TREG_SYSCALL_NR];
273 void do_syscall_trace_exit(struct pt_regs *regs)
278 * The standard tile calling convention returns the value (or negative
279 * errno) in r0, and zero (or positive errno) in r1.
280 * It saves a couple of cycles on the hot path to do this work in
281 * registers only as we return, rather than updating the in-memory
284 errno = (long) regs->regs[0];
285 if (errno < 0 && errno > -4096)
286 regs->regs[1] = -errno;
290 if (test_thread_flag(TIF_SYSCALL_TRACE))
291 tracehook_report_syscall_exit(regs, 0);
293 if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
294 trace_sys_exit(regs, regs->regs[0]);
297 void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs)
301 memset(&info, 0, sizeof(info));
302 info.si_signo = SIGTRAP;
303 info.si_code = TRAP_BRKPT;
304 info.si_addr = (void __user *) regs->pc;
306 /* Send us the fakey SIGTRAP */
307 force_sig_info(SIGTRAP, &info, tsk);
310 /* Handle synthetic interrupt delivered only by the simulator. */
311 void __kprobes do_breakpoint(struct pt_regs* regs, int fault_num)
313 send_sigtrap(current, regs);