1 /*
2  *  PowerPC version
3  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
4  *
5  *  Derived from "arch/m68k/kernel/ptrace.c"
6  *  Copyright (C) 1994 by Hamish Macdonald
7  *  Taken from linux/kernel/ptrace.c and modified for M680x0.
8  *  linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
9  *
10  * Modified by Cort Dougan (cort@hq.fsmlabs.com)
11  * and Paul Mackerras (paulus@samba.org).
12  *
13  * This file is subject to the terms and conditions of the GNU General
14  * Public License.  See the file README.legal in the main directory of
15  * this archive for more details.
16  */
17 
18 #include <linux/regset.h>
19 #include <linux/tracehook.h>
20 #include <linux/audit.h>
21 #include <linux/context_tracking.h>
22 #include <linux/syscalls.h>
23 
24 #include <asm/switch_to.h>
25 #include <asm/asm-prototypes.h>
26 #include <asm/debug.h>
27 
28 #define CREATE_TRACE_POINTS
29 #include <trace/events/syscalls.h>
30 
31 #include "ptrace-decl.h"
32 
33 /*
34  * Called by kernel/ptrace.c when detaching..
35  *
36  * Make sure single step bits etc are not set.
37  */
38 void ptrace_disable(struct task_struct *child)
39 {
40 	/* make sure the single step bit is not set. */
41 	user_disable_single_step(child);
42 }
43 
44 long arch_ptrace(struct task_struct *child, long request,
45 		 unsigned long addr, unsigned long data)
46 {
47 	int ret = -EPERM;
48 	void __user *datavp = (void __user *) data;
49 	unsigned long __user *datalp = datavp;
50 
51 	switch (request) {
52 	/* read the word at location addr in the USER area. */
53 	case PTRACE_PEEKUSR: {
54 		unsigned long index, tmp;
55 
56 		ret = -EIO;
57 		/* convert to index and check */
58 		index = addr / sizeof(long);
59 		if ((addr & (sizeof(long) - 1)) || !child->thread.regs)
60 			break;
61 
62 		if (index < PT_FPR0)
63 			ret = ptrace_get_reg(child, (int) index, &tmp);
64 		else
65 			ret = ptrace_get_fpr(child, index, &tmp);
66 
67 		if (ret)
68 			break;
69 		ret = put_user(tmp, datalp);
70 		break;
71 	}
72 
73 	/* write the word at location addr in the USER area */
74 	case PTRACE_POKEUSR: {
75 		unsigned long index;
76 
77 		ret = -EIO;
78 		/* convert to index and check */
79 		index = addr / sizeof(long);
80 		if ((addr & (sizeof(long) - 1)) || !child->thread.regs)
81 			break;
82 
83 		if (index < PT_FPR0)
84 			ret = ptrace_put_reg(child, index, data);
85 		else
86 			ret = ptrace_put_fpr(child, index, data);
87 		break;
88 	}
89 
90 	case PPC_PTRACE_GETHWDBGINFO: {
91 		struct ppc_debug_info dbginfo;
92 
93 		ppc_gethwdinfo(&dbginfo);
94 
95 		if (copy_to_user(datavp, &dbginfo,
96 				 sizeof(struct ppc_debug_info)))
97 			return -EFAULT;
98 		return 0;
99 	}
100 
101 	case PPC_PTRACE_SETHWDEBUG: {
102 		struct ppc_hw_breakpoint bp_info;
103 
104 		if (copy_from_user(&bp_info, datavp,
105 				   sizeof(struct ppc_hw_breakpoint)))
106 			return -EFAULT;
107 		return ppc_set_hwdebug(child, &bp_info);
108 	}
109 
110 	case PPC_PTRACE_DELHWDEBUG: {
111 		ret = ppc_del_hwdebug(child, data);
112 		break;
113 	}
114 
115 	case PTRACE_GET_DEBUGREG:
116 		ret = ptrace_get_debugreg(child, addr, datalp);
117 		break;
118 
119 	case PTRACE_SET_DEBUGREG:
120 		ret = ptrace_set_debugreg(child, addr, data);
121 		break;
122 
123 #ifdef CONFIG_PPC64
124 	case PTRACE_GETREGS64:
125 #endif
126 	case PTRACE_GETREGS:	/* Get all pt_regs from the child. */
127 		return copy_regset_to_user(child, &user_ppc_native_view,
128 					   REGSET_GPR,
129 					   0, sizeof(struct user_pt_regs),
130 					   datavp);
131 
132 #ifdef CONFIG_PPC64
133 	case PTRACE_SETREGS64:
134 #endif
135 	case PTRACE_SETREGS:	/* Set all gp regs in the child. */
136 		return copy_regset_from_user(child, &user_ppc_native_view,
137 					     REGSET_GPR,
138 					     0, sizeof(struct user_pt_regs),
139 					     datavp);
140 
141 	case PTRACE_GETFPREGS: /* Get the child FPU state (FPR0...31 + FPSCR) */
142 		return copy_regset_to_user(child, &user_ppc_native_view,
143 					   REGSET_FPR,
144 					   0, sizeof(elf_fpregset_t),
145 					   datavp);
146 
147 	case PTRACE_SETFPREGS: /* Set the child FPU state (FPR0...31 + FPSCR) */
148 		return copy_regset_from_user(child, &user_ppc_native_view,
149 					     REGSET_FPR,
150 					     0, sizeof(elf_fpregset_t),
151 					     datavp);
152 
153 #ifdef CONFIG_ALTIVEC
154 	case PTRACE_GETVRREGS:
155 		return copy_regset_to_user(child, &user_ppc_native_view,
156 					   REGSET_VMX,
157 					   0, (33 * sizeof(vector128) +
158 					       sizeof(u32)),
159 					   datavp);
160 
161 	case PTRACE_SETVRREGS:
162 		return copy_regset_from_user(child, &user_ppc_native_view,
163 					     REGSET_VMX,
164 					     0, (33 * sizeof(vector128) +
165 						 sizeof(u32)),
166 					     datavp);
167 #endif
168 #ifdef CONFIG_VSX
169 	case PTRACE_GETVSRREGS:
170 		return copy_regset_to_user(child, &user_ppc_native_view,
171 					   REGSET_VSX,
172 					   0, 32 * sizeof(double),
173 					   datavp);
174 
175 	case PTRACE_SETVSRREGS:
176 		return copy_regset_from_user(child, &user_ppc_native_view,
177 					     REGSET_VSX,
178 					     0, 32 * sizeof(double),
179 					     datavp);
180 #endif
181 #ifdef CONFIG_SPE
182 	case PTRACE_GETEVRREGS:
183 		/* Get the child spe register state. */
184 		return copy_regset_to_user(child, &user_ppc_native_view,
185 					   REGSET_SPE, 0, 35 * sizeof(u32),
186 					   datavp);
187 
188 	case PTRACE_SETEVRREGS:
189 		/* Set the child spe register state. */
190 		return copy_regset_from_user(child, &user_ppc_native_view,
191 					     REGSET_SPE, 0, 35 * sizeof(u32),
192 					     datavp);
193 #endif
194 
195 	default:
196 		ret = ptrace_request(child, request, addr, data);
197 		break;
198 	}
199 	return ret;
200 }
201 
202 #ifdef CONFIG_SECCOMP
203 static int do_seccomp(struct pt_regs *regs)
204 {
205 	if (!test_thread_flag(TIF_SECCOMP))
206 		return 0;
207 
208 	/*
209 	 * The ABI we present to seccomp tracers is that r3 contains
210 	 * the syscall return value and orig_gpr3 contains the first
211 	 * syscall parameter. This is different to the ptrace ABI where
212 	 * both r3 and orig_gpr3 contain the first syscall parameter.
213 	 */
214 	regs->gpr[3] = -ENOSYS;
215 
216 	/*
217 	 * We use the __ version here because we have already checked
218 	 * TIF_SECCOMP. If this fails, there is nothing left to do, we
219 	 * have already loaded -ENOSYS into r3, or seccomp has put
220 	 * something else in r3 (via SECCOMP_RET_ERRNO/TRACE).
221 	 */
222 	if (__secure_computing(NULL))
223 		return -1;
224 
225 	/*
226 	 * The syscall was allowed by seccomp, restore the register
227 	 * state to what audit expects.
228 	 * Note that we use orig_gpr3, which means a seccomp tracer can
229 	 * modify the first syscall parameter (in orig_gpr3) and also
230 	 * allow the syscall to proceed.
231 	 */
232 	regs->gpr[3] = regs->orig_gpr3;
233 
234 	return 0;
235 }
236 #else
237 static inline int do_seccomp(struct pt_regs *regs) { return 0; }
238 #endif /* CONFIG_SECCOMP */
239 
240 /**
241  * do_syscall_trace_enter() - Do syscall tracing on kernel entry.
242  * @regs: the pt_regs of the task to trace (current)
243  *
244  * Performs various types of tracing on syscall entry. This includes seccomp,
245  * ptrace, syscall tracepoints and audit.
246  *
247  * The pt_regs are potentially visible to userspace via ptrace, so their
248  * contents is ABI.
249  *
250  * One or more of the tracers may modify the contents of pt_regs, in particular
251  * to modify arguments or even the syscall number itself.
252  *
253  * It's also possible that a tracer can choose to reject the system call. In
254  * that case this function will return an illegal syscall number, and will put
255  * an appropriate return value in regs->r3.
256  *
257  * Return: the (possibly changed) syscall number.
258  */
259 long do_syscall_trace_enter(struct pt_regs *regs)
260 {
261 	u32 flags;
262 
263 	flags = READ_ONCE(current_thread_info()->flags) &
264 		(_TIF_SYSCALL_EMU | _TIF_SYSCALL_TRACE);
265 
266 	if (flags) {
267 		int rc = tracehook_report_syscall_entry(regs);
268 
269 		if (unlikely(flags & _TIF_SYSCALL_EMU)) {
270 			/*
271 			 * A nonzero return code from
272 			 * tracehook_report_syscall_entry() tells us to prevent
273 			 * the syscall execution, but we are not going to
274 			 * execute it anyway.
275 			 *
276 			 * Returning -1 will skip the syscall execution. We want
277 			 * to avoid clobbering any registers, so we don't goto
278 			 * the skip label below.
279 			 */
280 			return -1;
281 		}
282 
283 		if (rc) {
284 			/*
285 			 * The tracer decided to abort the syscall. Note that
286 			 * the tracer may also just change regs->gpr[0] to an
287 			 * invalid syscall number, that is handled below on the
288 			 * exit path.
289 			 */
290 			goto skip;
291 		}
292 	}
293 
294 	/* Run seccomp after ptrace; allow it to set gpr[3]. */
295 	if (do_seccomp(regs))
296 		return -1;
297 
298 	/* Avoid trace and audit when syscall is invalid. */
299 	if (regs->gpr[0] >= NR_syscalls)
300 		goto skip;
301 
302 	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
303 		trace_sys_enter(regs, regs->gpr[0]);
304 
305 	if (!is_32bit_task())
306 		audit_syscall_entry(regs->gpr[0], regs->gpr[3], regs->gpr[4],
307 				    regs->gpr[5], regs->gpr[6]);
308 	else
309 		audit_syscall_entry(regs->gpr[0],
310 				    regs->gpr[3] & 0xffffffff,
311 				    regs->gpr[4] & 0xffffffff,
312 				    regs->gpr[5] & 0xffffffff,
313 				    regs->gpr[6] & 0xffffffff);
314 
315 	/* Return the possibly modified but valid syscall number */
316 	return regs->gpr[0];
317 
318 skip:
319 	/*
320 	 * If we are aborting explicitly, or if the syscall number is
321 	 * now invalid, set the return value to -ENOSYS.
322 	 */
323 	regs->gpr[3] = -ENOSYS;
324 	return -1;
325 }
326 
327 void do_syscall_trace_leave(struct pt_regs *regs)
328 {
329 	int step;
330 
331 	audit_syscall_exit(regs);
332 
333 	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
334 		trace_sys_exit(regs, regs->result);
335 
336 	step = test_thread_flag(TIF_SINGLESTEP);
337 	if (step || test_thread_flag(TIF_SYSCALL_TRACE))
338 		tracehook_report_syscall_exit(regs, step);
339 }
340 
341 void __init pt_regs_check(void);
342 
343 /*
344  * Dummy function, its purpose is to break the build if struct pt_regs and
345  * struct user_pt_regs don't match.
346  */
347 void __init pt_regs_check(void)
348 {
349 	BUILD_BUG_ON(offsetof(struct pt_regs, gpr) !=
350 		     offsetof(struct user_pt_regs, gpr));
351 	BUILD_BUG_ON(offsetof(struct pt_regs, nip) !=
352 		     offsetof(struct user_pt_regs, nip));
353 	BUILD_BUG_ON(offsetof(struct pt_regs, msr) !=
354 		     offsetof(struct user_pt_regs, msr));
355 	BUILD_BUG_ON(offsetof(struct pt_regs, orig_gpr3) !=
356 		     offsetof(struct user_pt_regs, orig_gpr3));
357 	BUILD_BUG_ON(offsetof(struct pt_regs, ctr) !=
358 		     offsetof(struct user_pt_regs, ctr));
359 	BUILD_BUG_ON(offsetof(struct pt_regs, link) !=
360 		     offsetof(struct user_pt_regs, link));
361 	BUILD_BUG_ON(offsetof(struct pt_regs, xer) !=
362 		     offsetof(struct user_pt_regs, xer));
363 	BUILD_BUG_ON(offsetof(struct pt_regs, ccr) !=
364 		     offsetof(struct user_pt_regs, ccr));
365 #ifdef __powerpc64__
366 	BUILD_BUG_ON(offsetof(struct pt_regs, softe) !=
367 		     offsetof(struct user_pt_regs, softe));
368 #else
369 	BUILD_BUG_ON(offsetof(struct pt_regs, mq) !=
370 		     offsetof(struct user_pt_regs, mq));
371 #endif
372 	BUILD_BUG_ON(offsetof(struct pt_regs, trap) !=
373 		     offsetof(struct user_pt_regs, trap));
374 	BUILD_BUG_ON(offsetof(struct pt_regs, dar) !=
375 		     offsetof(struct user_pt_regs, dar));
376 	BUILD_BUG_ON(offsetof(struct pt_regs, dear) !=
377 		     offsetof(struct user_pt_regs, dar));
378 	BUILD_BUG_ON(offsetof(struct pt_regs, dsisr) !=
379 		     offsetof(struct user_pt_regs, dsisr));
380 	BUILD_BUG_ON(offsetof(struct pt_regs, esr) !=
381 		     offsetof(struct user_pt_regs, dsisr));
382 	BUILD_BUG_ON(offsetof(struct pt_regs, result) !=
383 		     offsetof(struct user_pt_regs, result));
384 
385 	BUILD_BUG_ON(sizeof(struct user_pt_regs) > sizeof(struct pt_regs));
386 
387 	// Now check that the pt_regs offsets match the uapi #defines
388 	#define CHECK_REG(_pt, _reg) \
389 		BUILD_BUG_ON(_pt != (offsetof(struct user_pt_regs, _reg) / \
390 				     sizeof(unsigned long)));
391 
392 	CHECK_REG(PT_R0,  gpr[0]);
393 	CHECK_REG(PT_R1,  gpr[1]);
394 	CHECK_REG(PT_R2,  gpr[2]);
395 	CHECK_REG(PT_R3,  gpr[3]);
396 	CHECK_REG(PT_R4,  gpr[4]);
397 	CHECK_REG(PT_R5,  gpr[5]);
398 	CHECK_REG(PT_R6,  gpr[6]);
399 	CHECK_REG(PT_R7,  gpr[7]);
400 	CHECK_REG(PT_R8,  gpr[8]);
401 	CHECK_REG(PT_R9,  gpr[9]);
402 	CHECK_REG(PT_R10, gpr[10]);
403 	CHECK_REG(PT_R11, gpr[11]);
404 	CHECK_REG(PT_R12, gpr[12]);
405 	CHECK_REG(PT_R13, gpr[13]);
406 	CHECK_REG(PT_R14, gpr[14]);
407 	CHECK_REG(PT_R15, gpr[15]);
408 	CHECK_REG(PT_R16, gpr[16]);
409 	CHECK_REG(PT_R17, gpr[17]);
410 	CHECK_REG(PT_R18, gpr[18]);
411 	CHECK_REG(PT_R19, gpr[19]);
412 	CHECK_REG(PT_R20, gpr[20]);
413 	CHECK_REG(PT_R21, gpr[21]);
414 	CHECK_REG(PT_R22, gpr[22]);
415 	CHECK_REG(PT_R23, gpr[23]);
416 	CHECK_REG(PT_R24, gpr[24]);
417 	CHECK_REG(PT_R25, gpr[25]);
418 	CHECK_REG(PT_R26, gpr[26]);
419 	CHECK_REG(PT_R27, gpr[27]);
420 	CHECK_REG(PT_R28, gpr[28]);
421 	CHECK_REG(PT_R29, gpr[29]);
422 	CHECK_REG(PT_R30, gpr[30]);
423 	CHECK_REG(PT_R31, gpr[31]);
424 	CHECK_REG(PT_NIP, nip);
425 	CHECK_REG(PT_MSR, msr);
426 	CHECK_REG(PT_ORIG_R3, orig_gpr3);
427 	CHECK_REG(PT_CTR, ctr);
428 	CHECK_REG(PT_LNK, link);
429 	CHECK_REG(PT_XER, xer);
430 	CHECK_REG(PT_CCR, ccr);
431 #ifdef CONFIG_PPC64
432 	CHECK_REG(PT_SOFTE, softe);
433 #else
434 	CHECK_REG(PT_MQ, mq);
435 #endif
436 	CHECK_REG(PT_TRAP, trap);
437 	CHECK_REG(PT_DAR, dar);
438 	CHECK_REG(PT_DSISR, dsisr);
439 	CHECK_REG(PT_RESULT, result);
440 	#undef CHECK_REG
441 
442 	BUILD_BUG_ON(PT_REGS_COUNT != sizeof(struct user_pt_regs) / sizeof(unsigned long));
443 
444 	/*
445 	 * PT_DSCR isn't a real reg, but it's important that it doesn't overlap the
446 	 * real registers.
447 	 */
448 	BUILD_BUG_ON(PT_DSCR < sizeof(struct user_pt_regs) / sizeof(unsigned long));
449 }
450