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 <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>
28
29#define CREATE_TRACE_POINTS
30#include <trace/events/syscalls.h>
31
32void user_enable_single_step(struct task_struct *child)
33{
34 set_tsk_thread_flag(child, TIF_SINGLESTEP);
35}
36
37void user_disable_single_step(struct task_struct *child)
38{
39 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
40}
41
42/*
43 * Called by kernel/ptrace.c when detaching..
44 */
45void ptrace_disable(struct task_struct *child)
46{
47 clear_tsk_thread_flag(child, TIF_SINGLESTEP);
48
49 /*
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.
52 */
53 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
54}
55
56/*
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.
62 */
63static char *getregs(struct task_struct *child, struct pt_regs *uregs)
64{
65 *uregs = *task_pt_regs(child);
66
67 /* Set up flags ABI bits. */
68 uregs->flags = 0;
69#ifdef CONFIG_COMPAT
70 if (task_thread_info(child)->status & TS_COMPAT)
71 uregs->flags |= PT_FLAGS_COMPAT;
72#endif
73
74 return (char *)uregs;
75}
76
77/* Put registers back to task. */
78static void putregs(struct task_struct *child, struct pt_regs *uregs)
79{
80 struct pt_regs *regs = task_pt_regs(child);
81
82 /* Don't allow overwriting the kernel-internal flags word. */
83 uregs->flags = regs->flags;
84
85 /* Only allow setting the ICS bit in the ex1 word. */
86 uregs->ex1 = PL_ICS_EX1(USER_PL, EX1_ICS(uregs->ex1));
87
88 *regs = *uregs;
89}
90
91enum tile_regset {
92 REGSET_GPR,
93};
94
95static 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)
99{
100 struct pt_regs regs;
101
102 getregs(target, ®s);
103
104 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, ®s, 0,
105 sizeof(regs));
106}
107
108static 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)
112{
113 int ret;
114 struct pt_regs regs = *task_pt_regs(target);
115
116 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, ®s, 0,
117 sizeof(regs));
118 if (ret)
119 return ret;
120
121 putregs(target, ®s);
122
123 return 0;
124}
125
126static const struct user_regset tile_user_regset[] = {
127 [REGSET_GPR] = {
128 .core_note_type = NT_PRSTATUS,
129 .n = ELF_NGREG,
130 .size = sizeof(elf_greg_t),
131 .align = sizeof(elf_greg_t),
132 .get = tile_gpr_get,
133 .set = tile_gpr_set,
134 },
135};
136
137static 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),
143};
144
145const struct user_regset_view *task_user_regset_view(struct task_struct *task)
146{
147 return &tile_user_regset_view;
148}
149
150long arch_ptrace(struct task_struct *child, long request,
151 unsigned long addr, unsigned long data)
152{
153 unsigned long __user *datap = (long __user __force *)data;
154 unsigned long tmp;
155 long ret = -EIO;
156 char *childreg;
157 struct pt_regs copyregs;
158
159 switch (request) {
160
161 case PTRACE_PEEKUSR: /* Read register from pt_regs. */
162 if (addr >= PTREGS_SIZE)
163 break;
164 childreg = getregs(child, ©regs) + addr;
165#ifdef CONFIG_COMPAT
166 if (is_compat_task()) {
167 if (addr & (sizeof(compat_long_t)-1))
168 break;
169 ret = put_user(*(compat_long_t *)childreg,
170 (compat_long_t __user *)datap);
171 } else
172#endif
173 {
174 if (addr & (sizeof(long)-1))
175 break;
176 ret = put_user(*(long *)childreg, datap);
177 }
178 break;
179
180 case PTRACE_POKEUSR: /* Write register in pt_regs. */
181 if (addr >= PTREGS_SIZE)
182 break;
183 childreg = getregs(child, ©regs) + addr;
184#ifdef CONFIG_COMPAT
185 if (is_compat_task()) {
186 if (addr & (sizeof(compat_long_t)-1))
187 break;
188 *(compat_long_t *)childreg = data;
189 } else
190#endif
191 {
192 if (addr & (sizeof(long)-1))
193 break;
194 *(long *)childreg = data;
195 }
196 putregs(child, ©regs);
197 ret = 0;
198 break;
199
200 case PTRACE_GETREGS: /* Get all registers from the child. */
201 ret = copy_regset_to_user(child, &tile_user_regset_view,
202 REGSET_GPR, 0,
203 sizeof(struct pt_regs), datap);
204 break;
205
206 case PTRACE_SETREGS: /* Set all registers in the child. */
207 ret = copy_regset_from_user(child, &tile_user_regset_view,
208 REGSET_GPR, 0,
209 sizeof(struct pt_regs), datap);
210 break;
211
212 case PTRACE_GETFPREGS: /* Get the child FPU state. */
213 case PTRACE_SETFPREGS: /* Set the child FPU state. */
214 break;
215
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);
222 if (ret == 0) {
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;
227 }
228 break;
229
230 default:
231#ifdef CONFIG_COMPAT
232 if (task_thread_info(current)->status & TS_COMPAT) {
233 ret = compat_ptrace_request(child, request,
234 addr, data);
235 break;
236 }
237#endif
238 ret = ptrace_request(child, request, addr, data);
239 break;
240 }
241
242 return ret;
243}
244
245#ifdef CONFIG_COMPAT
246/* Not used; we handle compat issues in arch_ptrace() directly. */
247long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
248 compat_ulong_t addr, compat_ulong_t data)
249{
250 BUG();
251}
252#endif
253
254int do_syscall_trace_enter(struct pt_regs *regs)
255{
256 u32 work = ACCESS_ONCE(current_thread_info()->flags);
257
258 if ((work & _TIF_SYSCALL_TRACE) &&
259 tracehook_report_syscall_entry(regs)) {
260 regs->regs[TREG_SYSCALL_NR] = -1;
261 return -1;
262 }
263
264 if (secure_computing(NULL) == -1)
265 return -1;
266
267 if (work & _TIF_SYSCALL_TRACEPOINT)
268 trace_sys_enter(regs, regs->regs[TREG_SYSCALL_NR]);
269
270 return regs->regs[TREG_SYSCALL_NR];
271}
272
273void do_syscall_trace_exit(struct pt_regs *regs)
274{
275 long errno;
276
277 /*
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
282 * struct ptregs.
283 */
284 errno = (long) regs->regs[0];
285 if (errno < 0 && errno > -4096)
286 regs->regs[1] = -errno;
287 else
288 regs->regs[1] = 0;
289
290 if (test_thread_flag(TIF_SYSCALL_TRACE))
291 tracehook_report_syscall_exit(regs, 0);
292
293 if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
294 trace_sys_exit(regs, regs->regs[0]);
295}
296
297void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs)
298{
299 struct siginfo info;
300
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;
305
306 /* Send us the fakey SIGTRAP */
307 force_sig_info(SIGTRAP, &info, tsk);
308}
309
310/* Handle synthetic interrupt delivered only by the simulator. */
311void __kprobes do_breakpoint(struct pt_regs* regs, int fault_num)
312{
313 send_sigtrap(current, regs);
314}
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}