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