1 /*
2 * Copyright (C) 2005-2012 Imagination Technologies Ltd.
3 *
4 * This file is subject to the terms and conditions of the GNU General
5 * Public License. See the file COPYING in the main directory of
6 * this archive for more details.
7 */
8
9 #include <linux/kernel.h>
10 #include <linux/mm.h>
11 #include <linux/errno.h>
12 #include <linux/ptrace.h>
13 #include <linux/user.h>
14 #include <linux/regset.h>
15 #include <linux/tracehook.h>
16 #include <linux/elf.h>
17 #include <linux/uaccess.h>
18 #include <linux/sched/task_stack.h>
19
20 #include <trace/syscall.h>
21
22 #define CREATE_TRACE_POINTS
23 #include <trace/events/syscalls.h>
24
25 /*
26 * user_regset definitions.
27 */
28
user_txstatus(const struct pt_regs * regs)29 static unsigned long user_txstatus(const struct pt_regs *regs)
30 {
31 unsigned long data = (unsigned long)regs->ctx.Flags;
32
33 if (regs->ctx.SaveMask & TBICTX_CBUF_BIT)
34 data |= USER_GP_REGS_STATUS_CATCH_BIT;
35
36 return data;
37 }
38
metag_gp_regs_copyout(const struct pt_regs * regs,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)39 int metag_gp_regs_copyout(const struct pt_regs *regs,
40 unsigned int pos, unsigned int count,
41 void *kbuf, void __user *ubuf)
42 {
43 const void *ptr;
44 unsigned long data;
45 int ret;
46
47 /* D{0-1}.{0-7} */
48 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
49 regs->ctx.DX, 0, 4*16);
50 if (ret)
51 goto out;
52 /* A{0-1}.{0-1} */
53 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
54 regs->ctx.AX, 4*16, 4*20);
55 if (ret)
56 goto out;
57 /* A{0-1}.2 */
58 if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
59 ptr = regs->ctx.Ext.Ctx.pExt;
60 else
61 ptr = ®s->ctx.Ext.AX2;
62 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
63 ptr, 4*20, 4*22);
64 if (ret)
65 goto out;
66 /* A{0-1}.3 */
67 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
68 ®s->ctx.AX3, 4*22, 4*24);
69 if (ret)
70 goto out;
71 /* PC */
72 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
73 ®s->ctx.CurrPC, 4*24, 4*25);
74 if (ret)
75 goto out;
76 /* TXSTATUS */
77 data = user_txstatus(regs);
78 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
79 &data, 4*25, 4*26);
80 if (ret)
81 goto out;
82 /* TXRPT, TXBPOBITS, TXMODE */
83 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
84 ®s->ctx.CurrRPT, 4*26, 4*29);
85 if (ret)
86 goto out;
87 /* Padding */
88 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
89 4*29, 4*30);
90 out:
91 return ret;
92 }
93
metag_gp_regs_copyin(struct pt_regs * regs,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)94 int metag_gp_regs_copyin(struct pt_regs *regs,
95 unsigned int pos, unsigned int count,
96 const void *kbuf, const void __user *ubuf)
97 {
98 void *ptr;
99 unsigned long data;
100 int ret;
101
102 /* D{0-1}.{0-7} */
103 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
104 regs->ctx.DX, 0, 4*16);
105 if (ret)
106 goto out;
107 /* A{0-1}.{0-1} */
108 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
109 regs->ctx.AX, 4*16, 4*20);
110 if (ret)
111 goto out;
112 /* A{0-1}.2 */
113 if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
114 ptr = regs->ctx.Ext.Ctx.pExt;
115 else
116 ptr = ®s->ctx.Ext.AX2;
117 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
118 ptr, 4*20, 4*22);
119 if (ret)
120 goto out;
121 /* A{0-1}.3 */
122 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
123 ®s->ctx.AX3, 4*22, 4*24);
124 if (ret)
125 goto out;
126 /* PC */
127 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
128 ®s->ctx.CurrPC, 4*24, 4*25);
129 if (ret)
130 goto out;
131 /* TXSTATUS */
132 data = user_txstatus(regs);
133 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
134 &data, 4*25, 4*26);
135 if (ret)
136 goto out;
137 regs->ctx.Flags = data & 0xffff;
138 if (data & USER_GP_REGS_STATUS_CATCH_BIT)
139 regs->ctx.SaveMask |= TBICTX_XCBF_BIT | TBICTX_CBUF_BIT;
140 else
141 regs->ctx.SaveMask &= ~TBICTX_CBUF_BIT;
142 /* TXRPT, TXBPOBITS, TXMODE */
143 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
144 ®s->ctx.CurrRPT, 4*26, 4*29);
145 out:
146 return ret;
147 }
148
metag_gp_regs_get(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)149 static int metag_gp_regs_get(struct task_struct *target,
150 const struct user_regset *regset,
151 unsigned int pos, unsigned int count,
152 void *kbuf, void __user *ubuf)
153 {
154 const struct pt_regs *regs = task_pt_regs(target);
155 return metag_gp_regs_copyout(regs, pos, count, kbuf, ubuf);
156 }
157
metag_gp_regs_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)158 static int metag_gp_regs_set(struct task_struct *target,
159 const struct user_regset *regset,
160 unsigned int pos, unsigned int count,
161 const void *kbuf, const void __user *ubuf)
162 {
163 struct pt_regs *regs = task_pt_regs(target);
164 return metag_gp_regs_copyin(regs, pos, count, kbuf, ubuf);
165 }
166
metag_cb_regs_copyout(const struct pt_regs * regs,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)167 int metag_cb_regs_copyout(const struct pt_regs *regs,
168 unsigned int pos, unsigned int count,
169 void *kbuf, void __user *ubuf)
170 {
171 int ret;
172
173 /* TXCATCH{0-3} */
174 if (regs->ctx.SaveMask & TBICTX_XCBF_BIT)
175 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
176 regs->extcb0, 0, 4*4);
177 else
178 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
179 0, 4*4);
180 return ret;
181 }
182
metag_cb_regs_copyin(struct pt_regs * regs,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)183 int metag_cb_regs_copyin(struct pt_regs *regs,
184 unsigned int pos, unsigned int count,
185 const void *kbuf, const void __user *ubuf)
186 {
187 int ret;
188
189 /* TXCATCH{0-3} */
190 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
191 regs->extcb0, 0, 4*4);
192 return ret;
193 }
194
metag_cb_regs_get(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)195 static int metag_cb_regs_get(struct task_struct *target,
196 const struct user_regset *regset,
197 unsigned int pos, unsigned int count,
198 void *kbuf, void __user *ubuf)
199 {
200 const struct pt_regs *regs = task_pt_regs(target);
201 return metag_cb_regs_copyout(regs, pos, count, kbuf, ubuf);
202 }
203
metag_cb_regs_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)204 static int metag_cb_regs_set(struct task_struct *target,
205 const struct user_regset *regset,
206 unsigned int pos, unsigned int count,
207 const void *kbuf, const void __user *ubuf)
208 {
209 struct pt_regs *regs = task_pt_regs(target);
210 return metag_cb_regs_copyin(regs, pos, count, kbuf, ubuf);
211 }
212
metag_rp_state_copyout(const struct pt_regs * regs,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)213 int metag_rp_state_copyout(const struct pt_regs *regs,
214 unsigned int pos, unsigned int count,
215 void *kbuf, void __user *ubuf)
216 {
217 unsigned long mask;
218 u64 *ptr;
219 int ret, i;
220
221 /* Empty read pipeline */
222 if (!(regs->ctx.SaveMask & TBICTX_CBRP_BIT)) {
223 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
224 0, 4*13);
225 goto out;
226 }
227
228 mask = (regs->ctx.CurrDIVTIME & TXDIVTIME_RPMASK_BITS) >>
229 TXDIVTIME_RPMASK_S;
230
231 /* Read pipeline entries */
232 ptr = (void *)®s->extcb0[1];
233 for (i = 0; i < 6; ++i, ++ptr) {
234 if (mask & (1 << i))
235 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
236 ptr, 8*i, 8*(i + 1));
237 else
238 ret = user_regset_copyout_zero(&pos, &count, &kbuf,
239 &ubuf, 8*i, 8*(i + 1));
240 if (ret)
241 goto out;
242 }
243 /* Mask of entries */
244 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
245 &mask, 4*12, 4*13);
246 out:
247 return ret;
248 }
249
metag_rp_state_copyin(struct pt_regs * regs,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)250 int metag_rp_state_copyin(struct pt_regs *regs,
251 unsigned int pos, unsigned int count,
252 const void *kbuf, const void __user *ubuf)
253 {
254 struct user_rp_state rp;
255 unsigned long long *ptr;
256 int ret, i;
257
258 if (count < 4*13)
259 return -EINVAL;
260 /* Read the entire pipeline before making any changes */
261 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
262 &rp, 0, 4*13);
263 if (ret)
264 goto out;
265
266 /* Write pipeline entries */
267 ptr = (void *)®s->extcb0[1];
268 for (i = 0; i < 6; ++i, ++ptr)
269 if (rp.mask & (1 << i))
270 *ptr = rp.entries[i];
271
272 /* Update RPMask in TXDIVTIME */
273 regs->ctx.CurrDIVTIME &= ~TXDIVTIME_RPMASK_BITS;
274 regs->ctx.CurrDIVTIME |= (rp.mask << TXDIVTIME_RPMASK_S)
275 & TXDIVTIME_RPMASK_BITS;
276
277 /* Set/clear flags to indicate catch/read pipeline state */
278 if (rp.mask)
279 regs->ctx.SaveMask |= TBICTX_XCBF_BIT | TBICTX_CBRP_BIT;
280 else
281 regs->ctx.SaveMask &= ~TBICTX_CBRP_BIT;
282 out:
283 return ret;
284 }
285
metag_rp_state_get(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)286 static int metag_rp_state_get(struct task_struct *target,
287 const struct user_regset *regset,
288 unsigned int pos, unsigned int count,
289 void *kbuf, void __user *ubuf)
290 {
291 const struct pt_regs *regs = task_pt_regs(target);
292 return metag_rp_state_copyout(regs, pos, count, kbuf, ubuf);
293 }
294
metag_rp_state_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)295 static int metag_rp_state_set(struct task_struct *target,
296 const struct user_regset *regset,
297 unsigned int pos, unsigned int count,
298 const void *kbuf, const void __user *ubuf)
299 {
300 struct pt_regs *regs = task_pt_regs(target);
301 return metag_rp_state_copyin(regs, pos, count, kbuf, ubuf);
302 }
303
metag_tls_get(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,void * kbuf,void __user * ubuf)304 static int metag_tls_get(struct task_struct *target,
305 const struct user_regset *regset,
306 unsigned int pos, unsigned int count,
307 void *kbuf, void __user *ubuf)
308 {
309 void __user *tls = target->thread.tls_ptr;
310 return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &tls, 0, -1);
311 }
312
metag_tls_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)313 static int metag_tls_set(struct task_struct *target,
314 const struct user_regset *regset,
315 unsigned int pos, unsigned int count,
316 const void *kbuf, const void __user *ubuf)
317 {
318 int ret;
319 void __user *tls = target->thread.tls_ptr;
320
321 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &tls, 0, -1);
322 if (ret)
323 return ret;
324
325 target->thread.tls_ptr = tls;
326 return ret;
327 }
328
329 enum metag_regset {
330 REGSET_GENERAL,
331 REGSET_CBUF,
332 REGSET_READPIPE,
333 REGSET_TLS,
334 };
335
336 static const struct user_regset metag_regsets[] = {
337 [REGSET_GENERAL] = {
338 .core_note_type = NT_PRSTATUS,
339 .n = ELF_NGREG,
340 .size = sizeof(long),
341 .align = sizeof(long long),
342 .get = metag_gp_regs_get,
343 .set = metag_gp_regs_set,
344 },
345 [REGSET_CBUF] = {
346 .core_note_type = NT_METAG_CBUF,
347 .n = sizeof(struct user_cb_regs) / sizeof(long),
348 .size = sizeof(long),
349 .align = sizeof(long long),
350 .get = metag_cb_regs_get,
351 .set = metag_cb_regs_set,
352 },
353 [REGSET_READPIPE] = {
354 .core_note_type = NT_METAG_RPIPE,
355 .n = sizeof(struct user_rp_state) / sizeof(long),
356 .size = sizeof(long),
357 .align = sizeof(long long),
358 .get = metag_rp_state_get,
359 .set = metag_rp_state_set,
360 },
361 [REGSET_TLS] = {
362 .core_note_type = NT_METAG_TLS,
363 .n = 1,
364 .size = sizeof(void *),
365 .align = sizeof(void *),
366 .get = metag_tls_get,
367 .set = metag_tls_set,
368 },
369 };
370
371 static const struct user_regset_view user_metag_view = {
372 .name = "metag",
373 .e_machine = EM_METAG,
374 .regsets = metag_regsets,
375 .n = ARRAY_SIZE(metag_regsets)
376 };
377
task_user_regset_view(struct task_struct * task)378 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
379 {
380 return &user_metag_view;
381 }
382
383 /*
384 * Called by kernel/ptrace.c when detaching..
385 *
386 * Make sure single step bits etc are not set.
387 */
ptrace_disable(struct task_struct * child)388 void ptrace_disable(struct task_struct *child)
389 {
390 /* nothing to do.. */
391 }
392
arch_ptrace(struct task_struct * child,long request,unsigned long addr,unsigned long data)393 long arch_ptrace(struct task_struct *child, long request, unsigned long addr,
394 unsigned long data)
395 {
396 int ret;
397
398 switch (request) {
399 default:
400 ret = ptrace_request(child, request, addr, data);
401 break;
402 }
403
404 return ret;
405 }
406
syscall_trace_enter(struct pt_regs * regs)407 int syscall_trace_enter(struct pt_regs *regs)
408 {
409 int ret = 0;
410
411 if (test_thread_flag(TIF_SYSCALL_TRACE))
412 ret = tracehook_report_syscall_entry(regs);
413
414 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
415 trace_sys_enter(regs, regs->ctx.DX[0].U1);
416
417 return ret ? -1 : regs->ctx.DX[0].U1;
418 }
419
syscall_trace_leave(struct pt_regs * regs)420 void syscall_trace_leave(struct pt_regs *regs)
421 {
422 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
423 trace_sys_exit(regs, regs->ctx.DX[0].U1);
424
425 if (test_thread_flag(TIF_SYSCALL_TRACE))
426 tracehook_report_syscall_exit(regs, 0);
427 }
428