Loading...
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
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.
7 *
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
12 * more details.
13 *
14 * Copied from i386: Ross Biro 1/23/92
15 */
16
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 <asm/traps.h>
23
24void user_enable_single_step(struct task_struct *child)
25{
26 set_tsk_thread_flag(child, TIF_SINGLESTEP);
27}
28
29void user_disable_single_step(struct task_struct *child)
30{
31 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
32}
33
34/*
35 * Called by kernel/ptrace.c when detaching..
36 */
37void ptrace_disable(struct task_struct *child)
38{
39 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
40
41 /*
42 * These two are currently unused, but will be set by arch_ptrace()
43 * and used in the syscall assembly when we do support them.
44 */
45 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
46}
47
48long arch_ptrace(struct task_struct *child, long request,
49 unsigned long addr, unsigned long data)
50{
51 unsigned long __user *datap = (long __user __force *)data;
52 unsigned long tmp;
53 long ret = -EIO;
54 char *childreg;
55 struct pt_regs copyregs;
56 int ex1_offset;
57
58 switch (request) {
59
60 case PTRACE_PEEKUSR: /* Read register from pt_regs. */
61 if (addr >= PTREGS_SIZE)
62 break;
63 childreg = (char *)task_pt_regs(child) + addr;
64#ifdef CONFIG_COMPAT
65 if (is_compat_task()) {
66 if (addr & (sizeof(compat_long_t)-1))
67 break;
68 ret = put_user(*(compat_long_t *)childreg,
69 (compat_long_t __user *)datap);
70 } else
71#endif
72 {
73 if (addr & (sizeof(long)-1))
74 break;
75 ret = put_user(*(long *)childreg, datap);
76 }
77 break;
78
79 case PTRACE_POKEUSR: /* Write register in pt_regs. */
80 if (addr >= PTREGS_SIZE)
81 break;
82 childreg = (char *)task_pt_regs(child) + addr;
83
84 /* Guard against overwrites of the privilege level. */
85 ex1_offset = PTREGS_OFFSET_EX1;
86#if defined(CONFIG_COMPAT) && defined(__BIG_ENDIAN)
87 if (is_compat_task()) /* point at low word */
88 ex1_offset += sizeof(compat_long_t);
89#endif
90 if (addr == ex1_offset)
91 data = PL_ICS_EX1(USER_PL, EX1_ICS(data));
92
93#ifdef CONFIG_COMPAT
94 if (is_compat_task()) {
95 if (addr & (sizeof(compat_long_t)-1))
96 break;
97 *(compat_long_t *)childreg = data;
98 } else
99#endif
100 {
101 if (addr & (sizeof(long)-1))
102 break;
103 *(long *)childreg = data;
104 }
105 ret = 0;
106 break;
107
108 case PTRACE_GETREGS: /* Get all registers from the child. */
109 if (copy_to_user(datap, task_pt_regs(child),
110 sizeof(struct pt_regs)) == 0) {
111 ret = 0;
112 }
113 break;
114
115 case PTRACE_SETREGS: /* Set all registers in the child. */
116 if (copy_from_user(©regs, datap,
117 sizeof(struct pt_regs)) == 0) {
118 copyregs.ex1 =
119 PL_ICS_EX1(USER_PL, EX1_ICS(copyregs.ex1));
120 *task_pt_regs(child) = copyregs;
121 ret = 0;
122 }
123 break;
124
125 case PTRACE_GETFPREGS: /* Get the child FPU state. */
126 case PTRACE_SETFPREGS: /* Set the child FPU state. */
127 break;
128
129 case PTRACE_SETOPTIONS:
130 /* Support TILE-specific ptrace options. */
131 child->ptrace &= ~PT_TRACE_MASK_TILE;
132 tmp = data & PTRACE_O_MASK_TILE;
133 data &= ~PTRACE_O_MASK_TILE;
134 ret = ptrace_request(child, request, addr, data);
135 if (tmp & PTRACE_O_TRACEMIGRATE)
136 child->ptrace |= PT_TRACE_MIGRATE;
137 break;
138
139 default:
140#ifdef CONFIG_COMPAT
141 if (task_thread_info(current)->status & TS_COMPAT) {
142 ret = compat_ptrace_request(child, request,
143 addr, data);
144 break;
145 }
146#endif
147 ret = ptrace_request(child, request, addr, data);
148 break;
149 }
150
151 return ret;
152}
153
154#ifdef CONFIG_COMPAT
155/* Not used; we handle compat issues in arch_ptrace() directly. */
156long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
157 compat_ulong_t addr, compat_ulong_t data)
158{
159 BUG();
160}
161#endif
162
163void do_syscall_trace(void)
164{
165 if (!test_thread_flag(TIF_SYSCALL_TRACE))
166 return;
167
168 if (!(current->ptrace & PT_PTRACED))
169 return;
170
171 /*
172 * The 0x80 provides a way for the tracing parent to distinguish
173 * between a syscall stop and SIGTRAP delivery
174 */
175 ptrace_notify(SIGTRAP|((current->ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
176
177 /*
178 * this isn't the same as continuing with a signal, but it will do
179 * for normal use. strace only continues with a signal if the
180 * stopping signal is not SIGTRAP. -brl
181 */
182 if (current->exit_code) {
183 send_sig(current->exit_code, current, 1);
184 current->exit_code = 0;
185 }
186}
187
188void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code)
189{
190 struct siginfo info;
191
192 memset(&info, 0, sizeof(info));
193 info.si_signo = SIGTRAP;
194 info.si_code = TRAP_BRKPT;
195 info.si_addr = (void __user *) regs->pc;
196
197 /* Send us the fakey SIGTRAP */
198 force_sig_info(SIGTRAP, &info, tsk);
199}
200
201/* Handle synthetic interrupt delivered only by the simulator. */
202void __kprobes do_breakpoint(struct pt_regs* regs, int fault_num)
203{
204 send_sigtrap(current, regs, fault_num);
205}
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
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.
7 *
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
12 * more details.
13 *
14 * Copied from i386: Ross Biro 1/23/92
15 */
16
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 <asm/traps.h>
26#include <arch/chip.h>
27
28#define CREATE_TRACE_POINTS
29#include <trace/events/syscalls.h>
30
31void user_enable_single_step(struct task_struct *child)
32{
33 set_tsk_thread_flag(child, TIF_SINGLESTEP);
34}
35
36void user_disable_single_step(struct task_struct *child)
37{
38 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
39}
40
41/*
42 * Called by kernel/ptrace.c when detaching..
43 */
44void ptrace_disable(struct task_struct *child)
45{
46 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
47
48 /*
49 * These two are currently unused, but will be set by arch_ptrace()
50 * and used in the syscall assembly when we do support them.
51 */
52 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
53}
54
55/*
56 * Get registers from task and ready the result for userspace.
57 * Note that we localize the API issues to getregs() and putregs() at
58 * some cost in performance, e.g. we need a full pt_regs copy for
59 * PEEKUSR, and two copies for POKEUSR. But in general we expect
60 * GETREGS/PUTREGS to be the API of choice anyway.
61 */
62static char *getregs(struct task_struct *child, struct pt_regs *uregs)
63{
64 *uregs = *task_pt_regs(child);
65
66 /* Set up flags ABI bits. */
67 uregs->flags = 0;
68#ifdef CONFIG_COMPAT
69 if (task_thread_info(child)->status & TS_COMPAT)
70 uregs->flags |= PT_FLAGS_COMPAT;
71#endif
72
73 return (char *)uregs;
74}
75
76/* Put registers back to task. */
77static void putregs(struct task_struct *child, struct pt_regs *uregs)
78{
79 struct pt_regs *regs = task_pt_regs(child);
80
81 /* Don't allow overwriting the kernel-internal flags word. */
82 uregs->flags = regs->flags;
83
84 /* Only allow setting the ICS bit in the ex1 word. */
85 uregs->ex1 = PL_ICS_EX1(USER_PL, EX1_ICS(uregs->ex1));
86
87 *regs = *uregs;
88}
89
90enum tile_regset {
91 REGSET_GPR,
92};
93
94static int tile_gpr_get(struct task_struct *target,
95 const struct user_regset *regset,
96 unsigned int pos, unsigned int count,
97 void *kbuf, void __user *ubuf)
98{
99 struct pt_regs regs;
100
101 getregs(target, ®s);
102
103 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s, 0,
104 sizeof(regs));
105}
106
107static int tile_gpr_set(struct task_struct *target,
108 const struct user_regset *regset,
109 unsigned int pos, unsigned int count,
110 const void *kbuf, const void __user *ubuf)
111{
112 int ret;
113 struct pt_regs regs;
114
115 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, ®s, 0,
116 sizeof(regs));
117 if (ret)
118 return ret;
119
120 putregs(target, ®s);
121
122 return 0;
123}
124
125static const struct user_regset tile_user_regset[] = {
126 [REGSET_GPR] = {
127 .core_note_type = NT_PRSTATUS,
128 .n = ELF_NGREG,
129 .size = sizeof(elf_greg_t),
130 .align = sizeof(elf_greg_t),
131 .get = tile_gpr_get,
132 .set = tile_gpr_set,
133 },
134};
135
136static const struct user_regset_view tile_user_regset_view = {
137 .name = CHIP_ARCH_NAME,
138 .e_machine = ELF_ARCH,
139 .ei_osabi = ELF_OSABI,
140 .regsets = tile_user_regset,
141 .n = ARRAY_SIZE(tile_user_regset),
142};
143
144const struct user_regset_view *task_user_regset_view(struct task_struct *task)
145{
146 return &tile_user_regset_view;
147}
148
149long arch_ptrace(struct task_struct *child, long request,
150 unsigned long addr, unsigned long data)
151{
152 unsigned long __user *datap = (long __user __force *)data;
153 unsigned long tmp;
154 long ret = -EIO;
155 char *childreg;
156 struct pt_regs copyregs;
157
158 switch (request) {
159
160 case PTRACE_PEEKUSR: /* Read register from pt_regs. */
161 if (addr >= PTREGS_SIZE)
162 break;
163 childreg = getregs(child, ©regs) + addr;
164#ifdef CONFIG_COMPAT
165 if (is_compat_task()) {
166 if (addr & (sizeof(compat_long_t)-1))
167 break;
168 ret = put_user(*(compat_long_t *)childreg,
169 (compat_long_t __user *)datap);
170 } else
171#endif
172 {
173 if (addr & (sizeof(long)-1))
174 break;
175 ret = put_user(*(long *)childreg, datap);
176 }
177 break;
178
179 case PTRACE_POKEUSR: /* Write register in pt_regs. */
180 if (addr >= PTREGS_SIZE)
181 break;
182 childreg = getregs(child, ©regs) + addr;
183#ifdef CONFIG_COMPAT
184 if (is_compat_task()) {
185 if (addr & (sizeof(compat_long_t)-1))
186 break;
187 *(compat_long_t *)childreg = data;
188 } else
189#endif
190 {
191 if (addr & (sizeof(long)-1))
192 break;
193 *(long *)childreg = data;
194 }
195 putregs(child, ©regs);
196 ret = 0;
197 break;
198
199 case PTRACE_GETREGS: /* Get all registers from the child. */
200 ret = copy_regset_to_user(child, &tile_user_regset_view,
201 REGSET_GPR, 0,
202 sizeof(struct pt_regs), datap);
203 break;
204
205 case PTRACE_SETREGS: /* Set all registers in the child. */
206 ret = copy_regset_from_user(child, &tile_user_regset_view,
207 REGSET_GPR, 0,
208 sizeof(struct pt_regs), datap);
209 break;
210
211 case PTRACE_GETFPREGS: /* Get the child FPU state. */
212 case PTRACE_SETFPREGS: /* Set the child FPU state. */
213 break;
214
215 case PTRACE_SETOPTIONS:
216 /* Support TILE-specific ptrace options. */
217 BUILD_BUG_ON(PTRACE_O_MASK_TILE & PTRACE_O_MASK);
218 tmp = data & PTRACE_O_MASK_TILE;
219 data &= ~PTRACE_O_MASK_TILE;
220 ret = ptrace_request(child, request, addr, data);
221 if (ret == 0) {
222 unsigned int flags = child->ptrace;
223 flags &= ~(PTRACE_O_MASK_TILE << PT_OPT_FLAG_SHIFT);
224 flags |= (tmp << PT_OPT_FLAG_SHIFT);
225 child->ptrace = flags;
226 }
227 break;
228
229 default:
230#ifdef CONFIG_COMPAT
231 if (task_thread_info(current)->status & TS_COMPAT) {
232 ret = compat_ptrace_request(child, request,
233 addr, data);
234 break;
235 }
236#endif
237 ret = ptrace_request(child, request, addr, data);
238 break;
239 }
240
241 return ret;
242}
243
244#ifdef CONFIG_COMPAT
245/* Not used; we handle compat issues in arch_ptrace() directly. */
246long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
247 compat_ulong_t addr, compat_ulong_t data)
248{
249 BUG();
250}
251#endif
252
253int do_syscall_trace_enter(struct pt_regs *regs)
254{
255 if (test_thread_flag(TIF_SYSCALL_TRACE)) {
256 if (tracehook_report_syscall_entry(regs))
257 regs->regs[TREG_SYSCALL_NR] = -1;
258 }
259
260 if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
261 trace_sys_enter(regs, regs->regs[TREG_SYSCALL_NR]);
262
263 return regs->regs[TREG_SYSCALL_NR];
264}
265
266void do_syscall_trace_exit(struct pt_regs *regs)
267{
268 long errno;
269
270 /*
271 * The standard tile calling convention returns the value (or negative
272 * errno) in r0, and zero (or positive errno) in r1.
273 * It saves a couple of cycles on the hot path to do this work in
274 * registers only as we return, rather than updating the in-memory
275 * struct ptregs.
276 */
277 errno = (long) regs->regs[0];
278 if (errno < 0 && errno > -4096)
279 regs->regs[1] = -errno;
280 else
281 regs->regs[1] = 0;
282
283 if (test_thread_flag(TIF_SYSCALL_TRACE))
284 tracehook_report_syscall_exit(regs, 0);
285
286 if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
287 trace_sys_exit(regs, regs->regs[0]);
288}
289
290void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs)
291{
292 struct siginfo info;
293
294 memset(&info, 0, sizeof(info));
295 info.si_signo = SIGTRAP;
296 info.si_code = TRAP_BRKPT;
297 info.si_addr = (void __user *) regs->pc;
298
299 /* Send us the fakey SIGTRAP */
300 force_sig_info(SIGTRAP, &info, tsk);
301}
302
303/* Handle synthetic interrupt delivered only by the simulator. */
304void __kprobes do_breakpoint(struct pt_regs* regs, int fault_num)
305{
306 send_sigtrap(current, regs);
307}