Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* ptrace.c: Sparc process tracing support. |
2 | * | |
d09c2a23 | 3 | * Copyright (C) 1996, 2008 David S. Miller (davem@davemloft.net) |
1da177e4 LT |
4 | * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) |
5 | * | |
6 | * Based upon code written by Ross Biro, Linus Torvalds, Bob Manson, | |
7 | * and David Mosberger. | |
8 | * | |
9 | * Added Linux support -miguel (weird, eh?, the original code was meant | |
10 | * to emulate SunOS). | |
11 | */ | |
12 | ||
13 | #include <linux/kernel.h> | |
14 | #include <linux/sched.h> | |
15 | #include <linux/mm.h> | |
16 | #include <linux/errno.h> | |
dc76f9ca | 17 | #include <linux/export.h> |
1da177e4 LT |
18 | #include <linux/ptrace.h> |
19 | #include <linux/user.h> | |
20 | #include <linux/smp.h> | |
1da177e4 | 21 | #include <linux/security.h> |
f7ceba36 DM |
22 | #include <linux/seccomp.h> |
23 | #include <linux/audit.h> | |
7ed20e1a | 24 | #include <linux/signal.h> |
d09c2a23 | 25 | #include <linux/regset.h> |
73ccefab | 26 | #include <linux/tracehook.h> |
c658ad1b | 27 | #include <trace/syscall.h> |
d09c2a23 DM |
28 | #include <linux/compat.h> |
29 | #include <linux/elf.h> | |
812cb83a | 30 | #include <linux/context_tracking.h> |
1da177e4 LT |
31 | |
32 | #include <asm/asi.h> | |
33 | #include <asm/pgtable.h> | |
1da177e4 LT |
34 | #include <asm/uaccess.h> |
35 | #include <asm/psrcompat.h> | |
36 | #include <asm/visasm.h> | |
37 | #include <asm/spitfire.h> | |
6a9b490d | 38 | #include <asm/page.h> |
717463d8 | 39 | #include <asm/cpudata.h> |
bfdf9ebc DM |
40 | #include <asm/cacheflush.h> |
41 | ||
c658ad1b DM |
42 | #define CREATE_TRACE_POINTS |
43 | #include <trace/events/syscalls.h> | |
44 | ||
bfdf9ebc | 45 | #include "entry.h" |
1da177e4 | 46 | |
1da177e4 | 47 | /* #define ALLOW_INIT_TRACING */ |
1da177e4 LT |
48 | |
49 | /* | |
50 | * Called by kernel/ptrace.c when detaching.. | |
51 | * | |
52 | * Make sure single step bits etc are not set. | |
53 | */ | |
54 | void ptrace_disable(struct task_struct *child) | |
55 | { | |
56 | /* nothing to do */ | |
57 | } | |
58 | ||
dadeafdf DM |
59 | /* To get the necessary page struct, access_process_vm() first calls |
60 | * get_user_pages(). This has done a flush_dcache_page() on the | |
61 | * accessed page. Then our caller (copy_{to,from}_user_page()) did | |
62 | * to memcpy to read/write the data from that page. | |
63 | * | |
64 | * Now, the only thing we have to do is: | |
65 | * 1) flush the D-cache if it's possible than an illegal alias | |
66 | * has been created | |
67 | * 2) flush the I-cache if this is pre-cheetah and we did a write | |
68 | */ | |
69 | void flush_ptrace_access(struct vm_area_struct *vma, struct page *page, | |
70 | unsigned long uaddr, void *kaddr, | |
71 | unsigned long len, int write) | |
72 | { | |
73 | BUG_ON(len > PAGE_SIZE); | |
74 | ||
7adb37fe DM |
75 | if (tlb_type == hypervisor) |
76 | return; | |
77 | ||
f6a843d9 DM |
78 | preempt_disable(); |
79 | ||
dadeafdf DM |
80 | #ifdef DCACHE_ALIASING_POSSIBLE |
81 | /* If bit 13 of the kernel address we used to access the | |
82 | * user page is the same as the virtual address that page | |
83 | * is mapped to in the user's address space, we can skip the | |
84 | * D-cache flush. | |
85 | */ | |
6a9b490d | 86 | if ((uaddr ^ (unsigned long) kaddr) & (1UL << 13)) { |
dadeafdf DM |
87 | unsigned long start = __pa(kaddr); |
88 | unsigned long end = start + len; | |
717463d8 DM |
89 | unsigned long dcache_line_size; |
90 | ||
91 | dcache_line_size = local_cpu_data().dcache_line_size; | |
dadeafdf DM |
92 | |
93 | if (tlb_type == spitfire) { | |
717463d8 | 94 | for (; start < end; start += dcache_line_size) |
6a9b490d | 95 | spitfire_put_dcache_tag(start & 0x3fe0, 0x0); |
dadeafdf | 96 | } else { |
717463d8 DM |
97 | start &= ~(dcache_line_size - 1); |
98 | for (; start < end; start += dcache_line_size) | |
dadeafdf DM |
99 | __asm__ __volatile__( |
100 | "stxa %%g0, [%0] %1\n\t" | |
101 | "membar #Sync" | |
102 | : /* no outputs */ | |
6a9b490d | 103 | : "r" (start), |
dadeafdf DM |
104 | "i" (ASI_DCACHE_INVALIDATE)); |
105 | } | |
106 | } | |
107 | #endif | |
108 | if (write && tlb_type == spitfire) { | |
109 | unsigned long start = (unsigned long) kaddr; | |
110 | unsigned long end = start + len; | |
717463d8 DM |
111 | unsigned long icache_line_size; |
112 | ||
113 | icache_line_size = local_cpu_data().icache_line_size; | |
dadeafdf | 114 | |
717463d8 | 115 | for (; start < end; start += icache_line_size) |
dadeafdf DM |
116 | flushi(start); |
117 | } | |
f6a843d9 DM |
118 | |
119 | preempt_enable(); | |
dadeafdf | 120 | } |
dc76f9ca | 121 | EXPORT_SYMBOL_GPL(flush_ptrace_access); |
dadeafdf | 122 | |
d786a4a6 DM |
123 | static int get_from_target(struct task_struct *target, unsigned long uaddr, |
124 | void *kbuf, int len) | |
125 | { | |
126 | if (target == current) { | |
127 | if (copy_from_user(kbuf, (void __user *) uaddr, len)) | |
128 | return -EFAULT; | |
129 | } else { | |
130 | int len2 = access_process_vm(target, uaddr, kbuf, len, 0); | |
131 | if (len2 != len) | |
132 | return -EFAULT; | |
133 | } | |
134 | return 0; | |
135 | } | |
136 | ||
137 | static int set_to_target(struct task_struct *target, unsigned long uaddr, | |
138 | void *kbuf, int len) | |
139 | { | |
140 | if (target == current) { | |
141 | if (copy_to_user((void __user *) uaddr, kbuf, len)) | |
142 | return -EFAULT; | |
143 | } else { | |
144 | int len2 = access_process_vm(target, uaddr, kbuf, len, 1); | |
145 | if (len2 != len) | |
146 | return -EFAULT; | |
147 | } | |
148 | return 0; | |
149 | } | |
150 | ||
151 | static int regwindow64_get(struct task_struct *target, | |
152 | const struct pt_regs *regs, | |
153 | struct reg_window *wbuf) | |
154 | { | |
155 | unsigned long rw_addr = regs->u_regs[UREG_I6]; | |
156 | ||
517ffce4 | 157 | if (!test_thread_64bit_stack(rw_addr)) { |
d786a4a6 DM |
158 | struct reg_window32 win32; |
159 | int i; | |
160 | ||
161 | if (get_from_target(target, rw_addr, &win32, sizeof(win32))) | |
162 | return -EFAULT; | |
163 | for (i = 0; i < 8; i++) | |
164 | wbuf->locals[i] = win32.locals[i]; | |
165 | for (i = 0; i < 8; i++) | |
166 | wbuf->ins[i] = win32.ins[i]; | |
167 | } else { | |
168 | rw_addr += STACK_BIAS; | |
169 | if (get_from_target(target, rw_addr, wbuf, sizeof(*wbuf))) | |
170 | return -EFAULT; | |
171 | } | |
172 | ||
173 | return 0; | |
174 | } | |
175 | ||
176 | static int regwindow64_set(struct task_struct *target, | |
177 | const struct pt_regs *regs, | |
178 | struct reg_window *wbuf) | |
179 | { | |
180 | unsigned long rw_addr = regs->u_regs[UREG_I6]; | |
181 | ||
517ffce4 | 182 | if (!test_thread_64bit_stack(rw_addr)) { |
d786a4a6 DM |
183 | struct reg_window32 win32; |
184 | int i; | |
185 | ||
186 | for (i = 0; i < 8; i++) | |
187 | win32.locals[i] = wbuf->locals[i]; | |
188 | for (i = 0; i < 8; i++) | |
189 | win32.ins[i] = wbuf->ins[i]; | |
190 | ||
191 | if (set_to_target(target, rw_addr, &win32, sizeof(win32))) | |
192 | return -EFAULT; | |
193 | } else { | |
194 | rw_addr += STACK_BIAS; | |
195 | if (set_to_target(target, rw_addr, wbuf, sizeof(*wbuf))) | |
196 | return -EFAULT; | |
197 | } | |
198 | ||
199 | return 0; | |
200 | } | |
201 | ||
d09c2a23 DM |
202 | enum sparc_regset { |
203 | REGSET_GENERAL, | |
204 | REGSET_FP, | |
205 | }; | |
206 | ||
207 | static int genregs64_get(struct task_struct *target, | |
208 | const struct user_regset *regset, | |
209 | unsigned int pos, unsigned int count, | |
210 | void *kbuf, void __user *ubuf) | |
211 | { | |
212 | const struct pt_regs *regs = task_pt_regs(target); | |
213 | int ret; | |
214 | ||
215 | if (target == current) | |
216 | flushw_user(); | |
217 | ||
218 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
219 | regs->u_regs, | |
220 | 0, 16 * sizeof(u64)); | |
d786a4a6 DM |
221 | if (!ret && count && pos < (32 * sizeof(u64))) { |
222 | struct reg_window window; | |
d09c2a23 | 223 | |
d786a4a6 DM |
224 | if (regwindow64_get(target, regs, &window)) |
225 | return -EFAULT; | |
d09c2a23 | 226 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, |
d786a4a6 | 227 | &window, |
d09c2a23 DM |
228 | 16 * sizeof(u64), |
229 | 32 * sizeof(u64)); | |
230 | } | |
231 | ||
232 | if (!ret) { | |
233 | /* TSTATE, TPC, TNPC */ | |
234 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
235 | ®s->tstate, | |
236 | 32 * sizeof(u64), | |
237 | 35 * sizeof(u64)); | |
238 | } | |
239 | ||
240 | if (!ret) { | |
241 | unsigned long y = regs->y; | |
242 | ||
243 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
244 | &y, | |
245 | 35 * sizeof(u64), | |
246 | 36 * sizeof(u64)); | |
247 | } | |
248 | ||
d786a4a6 | 249 | if (!ret) { |
d09c2a23 DM |
250 | ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, |
251 | 36 * sizeof(u64), -1); | |
252 | ||
d786a4a6 | 253 | } |
d09c2a23 DM |
254 | return ret; |
255 | } | |
256 | ||
257 | static int genregs64_set(struct task_struct *target, | |
258 | const struct user_regset *regset, | |
259 | unsigned int pos, unsigned int count, | |
260 | const void *kbuf, const void __user *ubuf) | |
261 | { | |
262 | struct pt_regs *regs = task_pt_regs(target); | |
263 | int ret; | |
264 | ||
265 | if (target == current) | |
266 | flushw_user(); | |
267 | ||
268 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
269 | regs->u_regs, | |
270 | 0, 16 * sizeof(u64)); | |
d786a4a6 DM |
271 | if (!ret && count && pos < (32 * sizeof(u64))) { |
272 | struct reg_window window; | |
d09c2a23 | 273 | |
d786a4a6 DM |
274 | if (regwindow64_get(target, regs, &window)) |
275 | return -EFAULT; | |
d09c2a23 DM |
276 | |
277 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
d786a4a6 | 278 | &window, |
d09c2a23 DM |
279 | 16 * sizeof(u64), |
280 | 32 * sizeof(u64)); | |
d786a4a6 DM |
281 | |
282 | if (!ret && | |
283 | regwindow64_set(target, regs, &window)) | |
284 | return -EFAULT; | |
d09c2a23 DM |
285 | } |
286 | ||
287 | if (!ret && count > 0) { | |
288 | unsigned long tstate; | |
289 | ||
290 | /* TSTATE */ | |
291 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
292 | &tstate, | |
293 | 32 * sizeof(u64), | |
294 | 33 * sizeof(u64)); | |
295 | if (!ret) { | |
28e61036 DM |
296 | /* Only the condition codes and the "in syscall" |
297 | * state can be modified in the %tstate register. | |
d09c2a23 | 298 | */ |
28e61036 DM |
299 | tstate &= (TSTATE_ICC | TSTATE_XCC | TSTATE_SYSCALL); |
300 | regs->tstate &= ~(TSTATE_ICC | TSTATE_XCC | TSTATE_SYSCALL); | |
d09c2a23 DM |
301 | regs->tstate |= tstate; |
302 | } | |
303 | } | |
304 | ||
305 | if (!ret) { | |
306 | /* TPC, TNPC */ | |
307 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
308 | ®s->tpc, | |
309 | 33 * sizeof(u64), | |
310 | 35 * sizeof(u64)); | |
311 | } | |
312 | ||
313 | if (!ret) { | |
314 | unsigned long y; | |
315 | ||
316 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
317 | &y, | |
318 | 35 * sizeof(u64), | |
319 | 36 * sizeof(u64)); | |
320 | if (!ret) | |
321 | regs->y = y; | |
322 | } | |
323 | ||
324 | if (!ret) | |
325 | ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, | |
326 | 36 * sizeof(u64), -1); | |
327 | ||
328 | return ret; | |
329 | } | |
330 | ||
331 | static int fpregs64_get(struct task_struct *target, | |
332 | const struct user_regset *regset, | |
333 | unsigned int pos, unsigned int count, | |
334 | void *kbuf, void __user *ubuf) | |
335 | { | |
336 | const unsigned long *fpregs = task_thread_info(target)->fpregs; | |
337 | unsigned long fprs, fsr, gsr; | |
338 | int ret; | |
339 | ||
340 | if (target == current) | |
341 | save_and_clear_fpu(); | |
342 | ||
343 | fprs = task_thread_info(target)->fpsaved[0]; | |
344 | ||
345 | if (fprs & FPRS_DL) | |
346 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
347 | fpregs, | |
348 | 0, 16 * sizeof(u64)); | |
349 | else | |
350 | ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, | |
351 | 0, | |
352 | 16 * sizeof(u64)); | |
353 | ||
354 | if (!ret) { | |
355 | if (fprs & FPRS_DU) | |
356 | ret = user_regset_copyout(&pos, &count, | |
357 | &kbuf, &ubuf, | |
358 | fpregs + 16, | |
359 | 16 * sizeof(u64), | |
360 | 32 * sizeof(u64)); | |
361 | else | |
362 | ret = user_regset_copyout_zero(&pos, &count, | |
363 | &kbuf, &ubuf, | |
364 | 16 * sizeof(u64), | |
365 | 32 * sizeof(u64)); | |
366 | } | |
367 | ||
368 | if (fprs & FPRS_FEF) { | |
369 | fsr = task_thread_info(target)->xfsr[0]; | |
370 | gsr = task_thread_info(target)->gsr[0]; | |
371 | } else { | |
372 | fsr = gsr = 0; | |
373 | } | |
374 | ||
375 | if (!ret) | |
376 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
377 | &fsr, | |
378 | 32 * sizeof(u64), | |
379 | 33 * sizeof(u64)); | |
380 | if (!ret) | |
381 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
382 | &gsr, | |
383 | 33 * sizeof(u64), | |
384 | 34 * sizeof(u64)); | |
385 | if (!ret) | |
386 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
387 | &fprs, | |
388 | 34 * sizeof(u64), | |
389 | 35 * sizeof(u64)); | |
390 | ||
391 | if (!ret) | |
392 | ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, | |
393 | 35 * sizeof(u64), -1); | |
394 | ||
395 | return ret; | |
396 | } | |
397 | ||
398 | static int fpregs64_set(struct task_struct *target, | |
399 | const struct user_regset *regset, | |
400 | unsigned int pos, unsigned int count, | |
401 | const void *kbuf, const void __user *ubuf) | |
402 | { | |
403 | unsigned long *fpregs = task_thread_info(target)->fpregs; | |
404 | unsigned long fprs; | |
405 | int ret; | |
406 | ||
407 | if (target == current) | |
408 | save_and_clear_fpu(); | |
409 | ||
410 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
411 | fpregs, | |
412 | 0, 32 * sizeof(u64)); | |
413 | if (!ret) | |
414 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
415 | task_thread_info(target)->xfsr, | |
416 | 32 * sizeof(u64), | |
417 | 33 * sizeof(u64)); | |
418 | if (!ret) | |
419 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
420 | task_thread_info(target)->gsr, | |
421 | 33 * sizeof(u64), | |
422 | 34 * sizeof(u64)); | |
423 | ||
424 | fprs = task_thread_info(target)->fpsaved[0]; | |
425 | if (!ret && count > 0) { | |
426 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
427 | &fprs, | |
428 | 34 * sizeof(u64), | |
429 | 35 * sizeof(u64)); | |
430 | } | |
431 | ||
432 | fprs |= (FPRS_FEF | FPRS_DL | FPRS_DU); | |
433 | task_thread_info(target)->fpsaved[0] = fprs; | |
434 | ||
435 | if (!ret) | |
436 | ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, | |
437 | 35 * sizeof(u64), -1); | |
438 | return ret; | |
439 | } | |
440 | ||
441 | static const struct user_regset sparc64_regsets[] = { | |
442 | /* Format is: | |
443 | * G0 --> G7 | |
444 | * O0 --> O7 | |
445 | * L0 --> L7 | |
446 | * I0 --> I7 | |
447 | * TSTATE, TPC, TNPC, Y | |
448 | */ | |
449 | [REGSET_GENERAL] = { | |
450 | .core_note_type = NT_PRSTATUS, | |
3c503701 | 451 | .n = 36, |
d09c2a23 DM |
452 | .size = sizeof(u64), .align = sizeof(u64), |
453 | .get = genregs64_get, .set = genregs64_set | |
454 | }, | |
455 | /* Format is: | |
456 | * F0 --> F63 | |
457 | * FSR | |
458 | * GSR | |
459 | * FPRS | |
460 | */ | |
461 | [REGSET_FP] = { | |
462 | .core_note_type = NT_PRFPREG, | |
3c503701 | 463 | .n = 35, |
d09c2a23 DM |
464 | .size = sizeof(u64), .align = sizeof(u64), |
465 | .get = fpregs64_get, .set = fpregs64_set | |
466 | }, | |
467 | }; | |
468 | ||
469 | static const struct user_regset_view user_sparc64_view = { | |
470 | .name = "sparc64", .e_machine = EM_SPARCV9, | |
471 | .regsets = sparc64_regsets, .n = ARRAY_SIZE(sparc64_regsets) | |
472 | }; | |
473 | ||
11cc8a3a | 474 | #ifdef CONFIG_COMPAT |
d09c2a23 DM |
475 | static int genregs32_get(struct task_struct *target, |
476 | const struct user_regset *regset, | |
477 | unsigned int pos, unsigned int count, | |
478 | void *kbuf, void __user *ubuf) | |
479 | { | |
480 | const struct pt_regs *regs = task_pt_regs(target); | |
481 | compat_ulong_t __user *reg_window; | |
482 | compat_ulong_t *k = kbuf; | |
483 | compat_ulong_t __user *u = ubuf; | |
484 | compat_ulong_t reg; | |
485 | ||
486 | if (target == current) | |
487 | flushw_user(); | |
488 | ||
489 | pos /= sizeof(reg); | |
490 | count /= sizeof(reg); | |
491 | ||
492 | if (kbuf) { | |
493 | for (; count > 0 && pos < 16; count--) | |
494 | *k++ = regs->u_regs[pos++]; | |
495 | ||
496 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | |
b857bd29 | 497 | reg_window -= 16; |
ad4f9576 DM |
498 | if (target == current) { |
499 | for (; count > 0 && pos < 32; count--) { | |
500 | if (get_user(*k++, ®_window[pos++])) | |
501 | return -EFAULT; | |
502 | } | |
503 | } else { | |
504 | for (; count > 0 && pos < 32; count--) { | |
505 | if (access_process_vm(target, | |
506 | (unsigned long) | |
507 | ®_window[pos], | |
508 | k, sizeof(*k), 0) | |
509 | != sizeof(*k)) | |
510 | return -EFAULT; | |
511 | k++; | |
512 | pos++; | |
513 | } | |
d09c2a23 DM |
514 | } |
515 | } else { | |
516 | for (; count > 0 && pos < 16; count--) { | |
517 | if (put_user((compat_ulong_t) regs->u_regs[pos++], u++)) | |
518 | return -EFAULT; | |
519 | } | |
520 | ||
521 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | |
b857bd29 | 522 | reg_window -= 16; |
ad4f9576 DM |
523 | if (target == current) { |
524 | for (; count > 0 && pos < 32; count--) { | |
525 | if (get_user(reg, ®_window[pos++]) || | |
526 | put_user(reg, u++)) | |
527 | return -EFAULT; | |
528 | } | |
529 | } else { | |
530 | for (; count > 0 && pos < 32; count--) { | |
531 | if (access_process_vm(target, | |
532 | (unsigned long) | |
533 | ®_window[pos], | |
534 | ®, sizeof(reg), 0) | |
535 | != sizeof(reg)) | |
536 | return -EFAULT; | |
537 | if (access_process_vm(target, | |
538 | (unsigned long) u, | |
539 | ®, sizeof(reg), 1) | |
540 | != sizeof(reg)) | |
541 | return -EFAULT; | |
542 | pos++; | |
543 | u++; | |
544 | } | |
d09c2a23 DM |
545 | } |
546 | } | |
547 | while (count > 0) { | |
548 | switch (pos) { | |
549 | case 32: /* PSR */ | |
550 | reg = tstate_to_psr(regs->tstate); | |
551 | break; | |
552 | case 33: /* PC */ | |
553 | reg = regs->tpc; | |
554 | break; | |
555 | case 34: /* NPC */ | |
556 | reg = regs->tnpc; | |
557 | break; | |
558 | case 35: /* Y */ | |
559 | reg = regs->y; | |
560 | break; | |
561 | case 36: /* WIM */ | |
562 | case 37: /* TBR */ | |
563 | reg = 0; | |
564 | break; | |
565 | default: | |
566 | goto finish; | |
567 | } | |
568 | ||
569 | if (kbuf) | |
570 | *k++ = reg; | |
571 | else if (put_user(reg, u++)) | |
572 | return -EFAULT; | |
573 | pos++; | |
574 | count--; | |
575 | } | |
576 | finish: | |
577 | pos *= sizeof(reg); | |
578 | count *= sizeof(reg); | |
579 | ||
580 | return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, | |
581 | 38 * sizeof(reg), -1); | |
582 | } | |
583 | ||
584 | static int genregs32_set(struct task_struct *target, | |
585 | const struct user_regset *regset, | |
586 | unsigned int pos, unsigned int count, | |
587 | const void *kbuf, const void __user *ubuf) | |
588 | { | |
589 | struct pt_regs *regs = task_pt_regs(target); | |
590 | compat_ulong_t __user *reg_window; | |
591 | const compat_ulong_t *k = kbuf; | |
592 | const compat_ulong_t __user *u = ubuf; | |
593 | compat_ulong_t reg; | |
594 | ||
595 | if (target == current) | |
596 | flushw_user(); | |
597 | ||
598 | pos /= sizeof(reg); | |
599 | count /= sizeof(reg); | |
600 | ||
601 | if (kbuf) { | |
602 | for (; count > 0 && pos < 16; count--) | |
603 | regs->u_regs[pos++] = *k++; | |
604 | ||
605 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | |
b857bd29 | 606 | reg_window -= 16; |
ad4f9576 DM |
607 | if (target == current) { |
608 | for (; count > 0 && pos < 32; count--) { | |
609 | if (put_user(*k++, ®_window[pos++])) | |
610 | return -EFAULT; | |
611 | } | |
612 | } else { | |
613 | for (; count > 0 && pos < 32; count--) { | |
614 | if (access_process_vm(target, | |
615 | (unsigned long) | |
616 | ®_window[pos], | |
617 | (void *) k, | |
618 | sizeof(*k), 1) | |
619 | != sizeof(*k)) | |
620 | return -EFAULT; | |
621 | k++; | |
622 | pos++; | |
623 | } | |
d09c2a23 DM |
624 | } |
625 | } else { | |
626 | for (; count > 0 && pos < 16; count--) { | |
627 | if (get_user(reg, u++)) | |
628 | return -EFAULT; | |
629 | regs->u_regs[pos++] = reg; | |
630 | } | |
631 | ||
632 | reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6]; | |
b857bd29 | 633 | reg_window -= 16; |
ad4f9576 DM |
634 | if (target == current) { |
635 | for (; count > 0 && pos < 32; count--) { | |
636 | if (get_user(reg, u++) || | |
637 | put_user(reg, ®_window[pos++])) | |
638 | return -EFAULT; | |
639 | } | |
640 | } else { | |
641 | for (; count > 0 && pos < 32; count--) { | |
642 | if (access_process_vm(target, | |
643 | (unsigned long) | |
644 | u, | |
645 | ®, sizeof(reg), 0) | |
646 | != sizeof(reg)) | |
647 | return -EFAULT; | |
648 | if (access_process_vm(target, | |
649 | (unsigned long) | |
650 | ®_window[pos], | |
651 | ®, sizeof(reg), 1) | |
652 | != sizeof(reg)) | |
653 | return -EFAULT; | |
654 | pos++; | |
655 | u++; | |
656 | } | |
d09c2a23 DM |
657 | } |
658 | } | |
659 | while (count > 0) { | |
660 | unsigned long tstate; | |
661 | ||
662 | if (kbuf) | |
663 | reg = *k++; | |
664 | else if (get_user(reg, u++)) | |
665 | return -EFAULT; | |
666 | ||
667 | switch (pos) { | |
668 | case 32: /* PSR */ | |
669 | tstate = regs->tstate; | |
28e61036 | 670 | tstate &= ~(TSTATE_ICC | TSTATE_XCC | TSTATE_SYSCALL); |
d09c2a23 | 671 | tstate |= psr_to_tstate_icc(reg); |
28e61036 DM |
672 | if (reg & PSR_SYSCALL) |
673 | tstate |= TSTATE_SYSCALL; | |
d09c2a23 DM |
674 | regs->tstate = tstate; |
675 | break; | |
676 | case 33: /* PC */ | |
677 | regs->tpc = reg; | |
678 | break; | |
679 | case 34: /* NPC */ | |
680 | regs->tnpc = reg; | |
681 | break; | |
682 | case 35: /* Y */ | |
683 | regs->y = reg; | |
684 | break; | |
685 | case 36: /* WIM */ | |
686 | case 37: /* TBR */ | |
687 | break; | |
688 | default: | |
689 | goto finish; | |
690 | } | |
691 | ||
692 | pos++; | |
693 | count--; | |
694 | } | |
695 | finish: | |
696 | pos *= sizeof(reg); | |
697 | count *= sizeof(reg); | |
698 | ||
699 | return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, | |
700 | 38 * sizeof(reg), -1); | |
701 | } | |
702 | ||
703 | static int fpregs32_get(struct task_struct *target, | |
704 | const struct user_regset *regset, | |
705 | unsigned int pos, unsigned int count, | |
706 | void *kbuf, void __user *ubuf) | |
707 | { | |
708 | const unsigned long *fpregs = task_thread_info(target)->fpregs; | |
709 | compat_ulong_t enabled; | |
710 | unsigned long fprs; | |
711 | compat_ulong_t fsr; | |
712 | int ret = 0; | |
713 | ||
714 | if (target == current) | |
715 | save_and_clear_fpu(); | |
716 | ||
717 | fprs = task_thread_info(target)->fpsaved[0]; | |
718 | if (fprs & FPRS_FEF) { | |
719 | fsr = task_thread_info(target)->xfsr[0]; | |
720 | enabled = 1; | |
721 | } else { | |
722 | fsr = 0; | |
723 | enabled = 0; | |
724 | } | |
725 | ||
726 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
727 | fpregs, | |
728 | 0, 32 * sizeof(u32)); | |
729 | ||
730 | if (!ret) | |
731 | ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, | |
732 | 32 * sizeof(u32), | |
733 | 33 * sizeof(u32)); | |
734 | if (!ret) | |
735 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
736 | &fsr, | |
737 | 33 * sizeof(u32), | |
738 | 34 * sizeof(u32)); | |
739 | ||
740 | if (!ret) { | |
741 | compat_ulong_t val; | |
742 | ||
743 | val = (enabled << 8) | (8 << 16); | |
744 | ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, | |
745 | &val, | |
746 | 34 * sizeof(u32), | |
747 | 35 * sizeof(u32)); | |
748 | } | |
749 | ||
750 | if (!ret) | |
751 | ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf, | |
752 | 35 * sizeof(u32), -1); | |
753 | ||
754 | return ret; | |
755 | } | |
756 | ||
757 | static int fpregs32_set(struct task_struct *target, | |
758 | const struct user_regset *regset, | |
759 | unsigned int pos, unsigned int count, | |
760 | const void *kbuf, const void __user *ubuf) | |
761 | { | |
762 | unsigned long *fpregs = task_thread_info(target)->fpregs; | |
763 | unsigned long fprs; | |
764 | int ret; | |
765 | ||
766 | if (target == current) | |
767 | save_and_clear_fpu(); | |
768 | ||
769 | fprs = task_thread_info(target)->fpsaved[0]; | |
770 | ||
771 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
772 | fpregs, | |
773 | 0, 32 * sizeof(u32)); | |
774 | if (!ret) | |
775 | user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, | |
776 | 32 * sizeof(u32), | |
777 | 33 * sizeof(u32)); | |
778 | if (!ret && count > 0) { | |
779 | compat_ulong_t fsr; | |
780 | unsigned long val; | |
781 | ||
782 | ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, | |
783 | &fsr, | |
784 | 33 * sizeof(u32), | |
785 | 34 * sizeof(u32)); | |
786 | if (!ret) { | |
787 | val = task_thread_info(target)->xfsr[0]; | |
788 | val &= 0xffffffff00000000UL; | |
789 | val |= fsr; | |
790 | task_thread_info(target)->xfsr[0] = val; | |
791 | } | |
792 | } | |
793 | ||
794 | fprs |= (FPRS_FEF | FPRS_DL); | |
795 | task_thread_info(target)->fpsaved[0] = fprs; | |
796 | ||
797 | if (!ret) | |
798 | ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, | |
799 | 34 * sizeof(u32), -1); | |
800 | return ret; | |
801 | } | |
802 | ||
803 | static const struct user_regset sparc32_regsets[] = { | |
804 | /* Format is: | |
805 | * G0 --> G7 | |
806 | * O0 --> O7 | |
807 | * L0 --> L7 | |
808 | * I0 --> I7 | |
809 | * PSR, PC, nPC, Y, WIM, TBR | |
810 | */ | |
811 | [REGSET_GENERAL] = { | |
812 | .core_note_type = NT_PRSTATUS, | |
3c503701 | 813 | .n = 38, |
d09c2a23 DM |
814 | .size = sizeof(u32), .align = sizeof(u32), |
815 | .get = genregs32_get, .set = genregs32_set | |
816 | }, | |
817 | /* Format is: | |
818 | * F0 --> F31 | |
819 | * empty 32-bit word | |
820 | * FSR (32--bit word) | |
821 | * FPU QUEUE COUNT (8-bit char) | |
822 | * FPU QUEUE ENTRYSIZE (8-bit char) | |
823 | * FPU ENABLED (8-bit char) | |
824 | * empty 8-bit char | |
825 | * FPU QUEUE (64 32-bit ints) | |
826 | */ | |
827 | [REGSET_FP] = { | |
828 | .core_note_type = NT_PRFPREG, | |
3c503701 | 829 | .n = 99, |
d09c2a23 DM |
830 | .size = sizeof(u32), .align = sizeof(u32), |
831 | .get = fpregs32_get, .set = fpregs32_set | |
832 | }, | |
833 | }; | |
834 | ||
835 | static const struct user_regset_view user_sparc32_view = { | |
836 | .name = "sparc", .e_machine = EM_SPARC, | |
837 | .regsets = sparc32_regsets, .n = ARRAY_SIZE(sparc32_regsets) | |
838 | }; | |
11cc8a3a | 839 | #endif /* CONFIG_COMPAT */ |
d09c2a23 DM |
840 | |
841 | const struct user_regset_view *task_user_regset_view(struct task_struct *task) | |
842 | { | |
11cc8a3a | 843 | #ifdef CONFIG_COMPAT |
d09c2a23 DM |
844 | if (test_tsk_thread_flag(task, TIF_32BIT)) |
845 | return &user_sparc32_view; | |
11cc8a3a | 846 | #endif |
d09c2a23 DM |
847 | return &user_sparc64_view; |
848 | } | |
849 | ||
11cc8a3a | 850 | #ifdef CONFIG_COMPAT |
2ba85f3a DM |
851 | struct compat_fps { |
852 | unsigned int regs[32]; | |
853 | unsigned int fsr; | |
854 | unsigned int flags; | |
855 | unsigned int extra; | |
856 | unsigned int fpqd; | |
857 | struct compat_fq { | |
858 | unsigned int insnaddr; | |
859 | unsigned int insn; | |
860 | } fpq[16]; | |
861 | }; | |
862 | ||
863 | long compat_arch_ptrace(struct task_struct *child, compat_long_t request, | |
864 | compat_ulong_t caddr, compat_ulong_t cdata) | |
1da177e4 | 865 | { |
d786a4a6 | 866 | const struct user_regset_view *view = task_user_regset_view(current); |
2ba85f3a DM |
867 | compat_ulong_t caddr2 = task_pt_regs(current)->u_regs[UREG_I4]; |
868 | struct pt_regs32 __user *pregs; | |
869 | struct compat_fps __user *fps; | |
870 | unsigned long addr2 = caddr2; | |
871 | unsigned long addr = caddr; | |
872 | unsigned long data = cdata; | |
9473272a | 873 | int ret; |
1da177e4 | 874 | |
2ba85f3a DM |
875 | pregs = (struct pt_regs32 __user *) addr; |
876 | fps = (struct compat_fps __user *) addr; | |
1da177e4 | 877 | |
2ba85f3a | 878 | switch (request) { |
1759e58e | 879 | case PTRACE_PEEKUSR: |
9775369e DM |
880 | ret = (addr != 0) ? -EIO : 0; |
881 | break; | |
1759e58e | 882 | |
2ba85f3a | 883 | case PTRACE_GETREGS: |
9473272a DM |
884 | ret = copy_regset_to_user(child, view, REGSET_GENERAL, |
885 | 32 * sizeof(u32), | |
886 | 4 * sizeof(u32), | |
887 | &pregs->psr); | |
888 | if (!ret) | |
889 | ret = copy_regset_to_user(child, view, REGSET_GENERAL, | |
890 | 1 * sizeof(u32), | |
891 | 15 * sizeof(u32), | |
892 | &pregs->u_regs[0]); | |
9775369e | 893 | break; |
9473272a | 894 | |
2ba85f3a | 895 | case PTRACE_SETREGS: |
9473272a DM |
896 | ret = copy_regset_from_user(child, view, REGSET_GENERAL, |
897 | 32 * sizeof(u32), | |
898 | 4 * sizeof(u32), | |
899 | &pregs->psr); | |
900 | if (!ret) | |
901 | ret = copy_regset_from_user(child, view, REGSET_GENERAL, | |
902 | 1 * sizeof(u32), | |
903 | 15 * sizeof(u32), | |
904 | &pregs->u_regs[0]); | |
9775369e | 905 | break; |
9775369e | 906 | |
2ba85f3a | 907 | case PTRACE_GETFPREGS: |
9473272a DM |
908 | ret = copy_regset_to_user(child, view, REGSET_FP, |
909 | 0 * sizeof(u32), | |
910 | 32 * sizeof(u32), | |
911 | &fps->regs[0]); | |
912 | if (!ret) | |
913 | ret = copy_regset_to_user(child, view, REGSET_FP, | |
914 | 33 * sizeof(u32), | |
915 | 1 * sizeof(u32), | |
916 | &fps->fsr); | |
917 | if (!ret) { | |
918 | if (__put_user(0, &fps->flags) || | |
919 | __put_user(0, &fps->extra) || | |
920 | __put_user(0, &fps->fpqd) || | |
921 | clear_user(&fps->fpq[0], 32 * sizeof(unsigned int))) | |
922 | ret = -EFAULT; | |
923 | } | |
9775369e | 924 | break; |
9775369e | 925 | |
2ba85f3a | 926 | case PTRACE_SETFPREGS: |
9473272a DM |
927 | ret = copy_regset_from_user(child, view, REGSET_FP, |
928 | 0 * sizeof(u32), | |
929 | 32 * sizeof(u32), | |
930 | &fps->regs[0]); | |
931 | if (!ret) | |
932 | ret = copy_regset_from_user(child, view, REGSET_FP, | |
933 | 33 * sizeof(u32), | |
934 | 1 * sizeof(u32), | |
935 | &fps->fsr); | |
9775369e | 936 | break; |
2ba85f3a DM |
937 | |
938 | case PTRACE_READTEXT: | |
939 | case PTRACE_READDATA: | |
940 | ret = ptrace_readdata(child, addr, | |
941 | (char __user *)addr2, data); | |
942 | if (ret == data) | |
943 | ret = 0; | |
944 | else if (ret >= 0) | |
945 | ret = -EIO; | |
946 | break; | |
947 | ||
948 | case PTRACE_WRITETEXT: | |
949 | case PTRACE_WRITEDATA: | |
950 | ret = ptrace_writedata(child, (char __user *) addr2, | |
951 | addr, data); | |
952 | if (ret == data) | |
953 | ret = 0; | |
954 | else if (ret >= 0) | |
955 | ret = -EIO; | |
956 | break; | |
957 | ||
958 | default: | |
986bef85 DM |
959 | if (request == PTRACE_SPARC_DETACH) |
960 | request = PTRACE_DETACH; | |
2ba85f3a DM |
961 | ret = compat_ptrace_request(child, request, addr, data); |
962 | break; | |
1da177e4 LT |
963 | } |
964 | ||
2ba85f3a DM |
965 | return ret; |
966 | } | |
11cc8a3a | 967 | #endif /* CONFIG_COMPAT */ |
2ba85f3a DM |
968 | |
969 | struct fps { | |
970 | unsigned int regs[64]; | |
971 | unsigned long fsr; | |
972 | }; | |
973 | ||
9b05a69e NK |
974 | long arch_ptrace(struct task_struct *child, long request, |
975 | unsigned long addr, unsigned long data) | |
2ba85f3a | 976 | { |
d786a4a6 | 977 | const struct user_regset_view *view = task_user_regset_view(current); |
2ba85f3a | 978 | unsigned long addr2 = task_pt_regs(current)->u_regs[UREG_I4]; |
bfdf9ebc DM |
979 | struct pt_regs __user *pregs; |
980 | struct fps __user *fps; | |
a9384e23 | 981 | void __user *addr2p; |
2ba85f3a DM |
982 | int ret; |
983 | ||
9b05a69e NK |
984 | pregs = (struct pt_regs __user *) addr; |
985 | fps = (struct fps __user *) addr; | |
a9384e23 | 986 | addr2p = (void __user *) addr2; |
bfdf9ebc | 987 | |
2ba85f3a DM |
988 | switch (request) { |
989 | case PTRACE_PEEKUSR: | |
990 | ret = (addr != 0) ? -EIO : 0; | |
991 | break; | |
9775369e | 992 | |
2ba85f3a DM |
993 | case PTRACE_GETREGS64: |
994 | ret = copy_regset_to_user(child, view, REGSET_GENERAL, | |
995 | 1 * sizeof(u64), | |
996 | 15 * sizeof(u64), | |
997 | &pregs->u_regs[0]); | |
998 | if (!ret) { | |
999 | /* XXX doesn't handle 'y' register correctly XXX */ | |
1000 | ret = copy_regset_to_user(child, view, REGSET_GENERAL, | |
1001 | 32 * sizeof(u64), | |
1002 | 4 * sizeof(u64), | |
1003 | &pregs->tstate); | |
1004 | } | |
1005 | break; | |
1006 | ||
1007 | case PTRACE_SETREGS64: | |
1008 | ret = copy_regset_from_user(child, view, REGSET_GENERAL, | |
1009 | 1 * sizeof(u64), | |
1010 | 15 * sizeof(u64), | |
1011 | &pregs->u_regs[0]); | |
1012 | if (!ret) { | |
1013 | /* XXX doesn't handle 'y' register correctly XXX */ | |
1014 | ret = copy_regset_from_user(child, view, REGSET_GENERAL, | |
1015 | 32 * sizeof(u64), | |
1016 | 4 * sizeof(u64), | |
1017 | &pregs->tstate); | |
1018 | } | |
1019 | break; | |
1020 | ||
1021 | case PTRACE_GETFPREGS64: | |
1022 | ret = copy_regset_to_user(child, view, REGSET_FP, | |
1023 | 0 * sizeof(u64), | |
1024 | 33 * sizeof(u64), | |
1025 | fps); | |
1026 | break; | |
1027 | ||
1028 | case PTRACE_SETFPREGS64: | |
ee4ee527 | 1029 | ret = copy_regset_from_user(child, view, REGSET_FP, |
9473272a DM |
1030 | 0 * sizeof(u64), |
1031 | 33 * sizeof(u64), | |
1032 | fps); | |
9775369e | 1033 | break; |
1da177e4 LT |
1034 | |
1035 | case PTRACE_READTEXT: | |
9775369e | 1036 | case PTRACE_READDATA: |
a9384e23 | 1037 | ret = ptrace_readdata(child, addr, addr2p, data); |
9775369e DM |
1038 | if (ret == data) |
1039 | ret = 0; | |
1040 | else if (ret >= 0) | |
1041 | ret = -EIO; | |
1042 | break; | |
1da177e4 LT |
1043 | |
1044 | case PTRACE_WRITETEXT: | |
9775369e | 1045 | case PTRACE_WRITEDATA: |
a9384e23 | 1046 | ret = ptrace_writedata(child, addr2p, addr, data); |
9775369e DM |
1047 | if (ret == data) |
1048 | ret = 0; | |
1049 | else if (ret >= 0) | |
1050 | ret = -EIO; | |
1051 | break; | |
1da177e4 | 1052 | |
9775369e | 1053 | default: |
986bef85 DM |
1054 | if (request == PTRACE_SPARC_DETACH) |
1055 | request = PTRACE_DETACH; | |
9775369e DM |
1056 | ret = ptrace_request(child, request, addr, data); |
1057 | break; | |
1da177e4 | 1058 | } |
9775369e DM |
1059 | |
1060 | return ret; | |
1da177e4 LT |
1061 | } |
1062 | ||
fe06ccaa | 1063 | asmlinkage int syscall_trace_enter(struct pt_regs *regs) |
1da177e4 | 1064 | { |
73ccefab RM |
1065 | int ret = 0; |
1066 | ||
bb49bcda | 1067 | /* do the secure computing check first */ |
e4da89d0 | 1068 | secure_computing_strict(regs->u_regs[UREG_G1]); |
bb49bcda | 1069 | |
812cb83a KT |
1070 | if (test_thread_flag(TIF_NOHZ)) |
1071 | user_exit(); | |
1072 | ||
fe06ccaa DM |
1073 | if (test_thread_flag(TIF_SYSCALL_TRACE)) |
1074 | ret = tracehook_report_syscall_entry(regs); | |
f7ceba36 | 1075 | |
c658ad1b DM |
1076 | if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT))) |
1077 | trace_sys_enter(regs, regs->u_regs[UREG_G1]); | |
1078 | ||
b05d8447 EP |
1079 | audit_syscall_entry((test_thread_flag(TIF_32BIT) ? |
1080 | AUDIT_ARCH_SPARC : | |
1081 | AUDIT_ARCH_SPARC64), | |
1082 | regs->u_regs[UREG_G1], | |
1083 | regs->u_regs[UREG_I0], | |
1084 | regs->u_regs[UREG_I1], | |
1085 | regs->u_regs[UREG_I2], | |
1086 | regs->u_regs[UREG_I3]); | |
73ccefab RM |
1087 | |
1088 | return ret; | |
1da177e4 | 1089 | } |
fe06ccaa DM |
1090 | |
1091 | asmlinkage void syscall_trace_leave(struct pt_regs *regs) | |
1092 | { | |
812cb83a KT |
1093 | if (test_thread_flag(TIF_NOHZ)) |
1094 | user_exit(); | |
1095 | ||
d7e7528b | 1096 | audit_syscall_exit(regs); |
fe06ccaa | 1097 | |
c658ad1b | 1098 | if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT))) |
04001552 | 1099 | trace_sys_exit(regs, regs->u_regs[UREG_I0]); |
c658ad1b | 1100 | |
fe06ccaa DM |
1101 | if (test_thread_flag(TIF_SYSCALL_TRACE)) |
1102 | tracehook_report_syscall_exit(regs, 0); | |
812cb83a KT |
1103 | |
1104 | if (test_thread_flag(TIF_NOHZ)) | |
1105 | user_enter(); | |
fe06ccaa | 1106 | } |