1 // SPDX-License-Identifier: GPL-2.0
2 /* ptrace.c: Sparc process tracing support.
3  *
4  * Copyright (C) 1996, 2008 David S. Miller (davem@davemloft.net)
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>
17 #include <linux/ptrace.h>
18 #include <linux/user.h>
19 #include <linux/smp.h>
20 #include <linux/security.h>
21 #include <linux/signal.h>
22 #include <linux/regset.h>
23 #include <linux/elf.h>
24 
25 #include <linux/uaccess.h>
26 #include <asm/cacheflush.h>
27 
28 #include "kernel.h"
29 
30 /* #define ALLOW_INIT_TRACING */
31 
32 /*
33  * Called by kernel/ptrace.c when detaching..
34  *
35  * Make sure single step bits etc are not set.
36  */
ptrace_disable(struct task_struct * child)37 void ptrace_disable(struct task_struct *child)
38 {
39 	/* nothing to do */
40 }
41 
42 enum sparc_regset {
43 	REGSET_GENERAL,
44 	REGSET_FP,
45 };
46 
regwindow32_get(struct task_struct * target,const struct pt_regs * regs,u32 * uregs)47 static int regwindow32_get(struct task_struct *target,
48 			   const struct pt_regs *regs,
49 			   u32 *uregs)
50 {
51 	unsigned long reg_window = regs->u_regs[UREG_I6];
52 	int size = 16 * sizeof(u32);
53 
54 	if (target == current) {
55 		if (copy_from_user(uregs, (void __user *)reg_window, size))
56 			return -EFAULT;
57 	} else {
58 		if (access_process_vm(target, reg_window, uregs, size,
59 				      FOLL_FORCE) != size)
60 			return -EFAULT;
61 	}
62 	return 0;
63 }
64 
regwindow32_set(struct task_struct * target,const struct pt_regs * regs,u32 * uregs)65 static int regwindow32_set(struct task_struct *target,
66 			   const struct pt_regs *regs,
67 			   u32 *uregs)
68 {
69 	unsigned long reg_window = regs->u_regs[UREG_I6];
70 	int size = 16 * sizeof(u32);
71 
72 	if (target == current) {
73 		if (copy_to_user((void __user *)reg_window, uregs, size))
74 			return -EFAULT;
75 	} else {
76 		if (access_process_vm(target, reg_window, uregs, size,
77 				      FOLL_FORCE | FOLL_WRITE) != size)
78 			return -EFAULT;
79 	}
80 	return 0;
81 }
82 
genregs32_get(struct task_struct * target,const struct user_regset * regset,struct membuf to)83 static int genregs32_get(struct task_struct *target,
84 			 const struct user_regset *regset,
85 			 struct membuf to)
86 {
87 	const struct pt_regs *regs = target->thread.kregs;
88 	u32 uregs[16];
89 
90 	if (target == current)
91 		flush_user_windows();
92 
93 	membuf_write(&to, regs->u_regs, 16 * sizeof(u32));
94 	if (!to.left)
95 		return 0;
96 	if (regwindow32_get(target, regs, uregs))
97 		return -EFAULT;
98 	membuf_write(&to, uregs, 16 * sizeof(u32));
99 	membuf_store(&to, regs->psr);
100 	membuf_store(&to, regs->pc);
101 	membuf_store(&to, regs->npc);
102 	membuf_store(&to, regs->y);
103 	return membuf_zero(&to, 2 * sizeof(u32));
104 }
105 
genregs32_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)106 static int genregs32_set(struct task_struct *target,
107 			 const struct user_regset *regset,
108 			 unsigned int pos, unsigned int count,
109 			 const void *kbuf, const void __user *ubuf)
110 {
111 	struct pt_regs *regs = target->thread.kregs;
112 	u32 uregs[16];
113 	u32 psr;
114 	int ret;
115 
116 	if (target == current)
117 		flush_user_windows();
118 
119 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
120 				 regs->u_regs,
121 				 0, 16 * sizeof(u32));
122 	if (ret || !count)
123 		return ret;
124 
125 	if (regwindow32_get(target, regs, uregs))
126 		return -EFAULT;
127 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
128 				 uregs,
129 				 16 * sizeof(u32), 32 * sizeof(u32));
130 	if (ret)
131 		return ret;
132 	if (regwindow32_set(target, regs, uregs))
133 		return -EFAULT;
134 	if (!count)
135 		return 0;
136 
137 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
138 				 &psr,
139 				 32 * sizeof(u32), 33 * sizeof(u32));
140 	if (ret)
141 		return ret;
142 	regs->psr = (regs->psr & ~(PSR_ICC | PSR_SYSCALL)) |
143 		    (psr & (PSR_ICC | PSR_SYSCALL));
144 	if (!count)
145 		return 0;
146 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
147 				 &regs->pc,
148 				 33 * sizeof(u32), 34 * sizeof(u32));
149 	if (ret || !count)
150 		return ret;
151 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
152 				 &regs->npc,
153 				 34 * sizeof(u32), 35 * sizeof(u32));
154 	if (ret || !count)
155 		return ret;
156 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
157 				 &regs->y,
158 				 35 * sizeof(u32), 36 * sizeof(u32));
159 	if (ret || !count)
160 		return ret;
161 	user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf, 36 * sizeof(u32),
162 				  38 * sizeof(u32));
163 	return 0;
164 }
165 
fpregs32_get(struct task_struct * target,const struct user_regset * regset,struct membuf to)166 static int fpregs32_get(struct task_struct *target,
167 			const struct user_regset *regset,
168 			struct membuf to)
169 {
170 #if 0
171 	if (target == current)
172 		save_and_clear_fpu();
173 #endif
174 
175 	membuf_write(&to, target->thread.float_regs, 32 * sizeof(u32));
176 	membuf_zero(&to, sizeof(u32));
177 	membuf_write(&to, &target->thread.fsr, sizeof(u32));
178 	membuf_store(&to, (u32)((1 << 8) | (8 << 16)));
179 	return membuf_zero(&to, 64 * sizeof(u32));
180 }
181 
fpregs32_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)182 static int fpregs32_set(struct task_struct *target,
183 			const struct user_regset *regset,
184 			unsigned int pos, unsigned int count,
185 			const void *kbuf, const void __user *ubuf)
186 {
187 	unsigned long *fpregs = target->thread.float_regs;
188 	int ret;
189 
190 #if 0
191 	if (target == current)
192 		save_and_clear_fpu();
193 #endif
194 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
195 				 fpregs,
196 				 0, 32 * sizeof(u32));
197 	if (!ret)
198 		user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
199 					  32 * sizeof(u32),
200 					  33 * sizeof(u32));
201 	if (!ret)
202 		ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
203 					 &target->thread.fsr,
204 					 33 * sizeof(u32),
205 					 34 * sizeof(u32));
206 	if (!ret)
207 		user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
208 					  34 * sizeof(u32), -1);
209 	return ret;
210 }
211 
212 static const struct user_regset sparc32_regsets[] = {
213 	/* Format is:
214 	 * 	G0 --> G7
215 	 *	O0 --> O7
216 	 *	L0 --> L7
217 	 *	I0 --> I7
218 	 *	PSR, PC, nPC, Y, WIM, TBR
219 	 */
220 	[REGSET_GENERAL] = {
221 		.core_note_type = NT_PRSTATUS,
222 		.n = 38,
223 		.size = sizeof(u32), .align = sizeof(u32),
224 		.regset_get = genregs32_get, .set = genregs32_set
225 	},
226 	/* Format is:
227 	 *	F0 --> F31
228 	 *	empty 32-bit word
229 	 *	FSR (32--bit word)
230 	 *	FPU QUEUE COUNT (8-bit char)
231 	 *	FPU QUEUE ENTRYSIZE (8-bit char)
232 	 *	FPU ENABLED (8-bit char)
233 	 *	empty 8-bit char
234 	 *	FPU QUEUE (64 32-bit ints)
235 	 */
236 	[REGSET_FP] = {
237 		.core_note_type = NT_PRFPREG,
238 		.n = 99,
239 		.size = sizeof(u32), .align = sizeof(u32),
240 		.regset_get = fpregs32_get, .set = fpregs32_set
241 	},
242 };
243 
getregs_get(struct task_struct * target,const struct user_regset * regset,struct membuf to)244 static int getregs_get(struct task_struct *target,
245 			 const struct user_regset *regset,
246 			 struct membuf to)
247 {
248 	const struct pt_regs *regs = target->thread.kregs;
249 
250 	if (target == current)
251 		flush_user_windows();
252 
253 	membuf_store(&to, regs->psr);
254 	membuf_store(&to, regs->pc);
255 	membuf_store(&to, regs->npc);
256 	membuf_store(&to, regs->y);
257 	return membuf_write(&to, regs->u_regs + 1, 15 * sizeof(u32));
258 }
259 
setregs_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)260 static int setregs_set(struct task_struct *target,
261 			 const struct user_regset *regset,
262 			 unsigned int pos, unsigned int count,
263 			 const void *kbuf, const void __user *ubuf)
264 {
265 	struct pt_regs *regs = target->thread.kregs;
266 	u32 v[4];
267 	int ret;
268 
269 	if (target == current)
270 		flush_user_windows();
271 
272 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
273 				 v,
274 				 0, 4 * sizeof(u32));
275 	if (ret)
276 		return ret;
277 	regs->psr = (regs->psr & ~(PSR_ICC | PSR_SYSCALL)) |
278 		    (v[0] & (PSR_ICC | PSR_SYSCALL));
279 	regs->pc = v[1];
280 	regs->npc = v[2];
281 	regs->y = v[3];
282 	return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
283 				 regs->u_regs + 1,
284 				 4 * sizeof(u32) , 19 * sizeof(u32));
285 }
286 
getfpregs_get(struct task_struct * target,const struct user_regset * regset,struct membuf to)287 static int getfpregs_get(struct task_struct *target,
288 			const struct user_regset *regset,
289 			struct membuf to)
290 {
291 #if 0
292 	if (target == current)
293 		save_and_clear_fpu();
294 #endif
295 	membuf_write(&to, &target->thread.float_regs, 32 * sizeof(u32));
296 	membuf_write(&to, &target->thread.fsr, sizeof(u32));
297 	return membuf_zero(&to, 35 * sizeof(u32));
298 }
299 
setfpregs_set(struct task_struct * target,const struct user_regset * regset,unsigned int pos,unsigned int count,const void * kbuf,const void __user * ubuf)300 static int setfpregs_set(struct task_struct *target,
301 			const struct user_regset *regset,
302 			unsigned int pos, unsigned int count,
303 			const void *kbuf, const void __user *ubuf)
304 {
305 	unsigned long *fpregs = target->thread.float_regs;
306 	int ret;
307 
308 #if 0
309 	if (target == current)
310 		save_and_clear_fpu();
311 #endif
312 	ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
313 				 fpregs,
314 				 0, 32 * sizeof(u32));
315 	if (ret)
316 		return ret;
317 	return user_regset_copyin(&pos, &count, &kbuf, &ubuf,
318 				 &target->thread.fsr,
319 				 32 * sizeof(u32),
320 				 33 * sizeof(u32));
321 }
322 
323 static const struct user_regset ptrace32_regsets[] = {
324 	[REGSET_GENERAL] = {
325 		.n = 19, .size = sizeof(u32),
326 		.regset_get = getregs_get, .set = setregs_set,
327 	},
328 	[REGSET_FP] = {
329 		.n = 68, .size = sizeof(u32),
330 		.regset_get = getfpregs_get, .set = setfpregs_set,
331 	},
332 };
333 
334 static const struct user_regset_view ptrace32_view = {
335 	.regsets = ptrace32_regsets, .n = ARRAY_SIZE(ptrace32_regsets)
336 };
337 
338 static const struct user_regset_view user_sparc32_view = {
339 	.name = "sparc", .e_machine = EM_SPARC,
340 	.regsets = sparc32_regsets, .n = ARRAY_SIZE(sparc32_regsets)
341 };
342 
task_user_regset_view(struct task_struct * task)343 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
344 {
345 	return &user_sparc32_view;
346 }
347 
348 struct fps {
349 	unsigned long regs[32];
350 	unsigned long fsr;
351 	unsigned long flags;
352 	unsigned long extra;
353 	unsigned long fpqd;
354 	struct fq {
355 		unsigned long *insnaddr;
356 		unsigned long insn;
357 	} fpq[16];
358 };
359 
arch_ptrace(struct task_struct * child,long request,unsigned long addr,unsigned long data)360 long arch_ptrace(struct task_struct *child, long request,
361 		 unsigned long addr, unsigned long data)
362 {
363 	unsigned long addr2 = current->thread.kregs->u_regs[UREG_I4];
364 	void __user *addr2p;
365 	struct pt_regs __user *pregs;
366 	struct fps __user *fps;
367 	int ret;
368 
369 	addr2p = (void __user *) addr2;
370 	pregs = (struct pt_regs __user *) addr;
371 	fps = (struct fps __user *) addr;
372 
373 	switch(request) {
374 	case PTRACE_GETREGS: {
375 		ret = copy_regset_to_user(child, &ptrace32_view,
376 					  REGSET_GENERAL, 0,
377 					  19 * sizeof(u32),
378 					  pregs);
379 		break;
380 	}
381 
382 	case PTRACE_SETREGS: {
383 		ret = copy_regset_from_user(child, &ptrace32_view,
384 					    REGSET_GENERAL, 0,
385 					    19 * sizeof(u32),
386 					    pregs);
387 		break;
388 	}
389 
390 	case PTRACE_GETFPREGS: {
391 		ret = copy_regset_to_user(child, &ptrace32_view,
392 					  REGSET_FP, 0,
393 					  68 * sizeof(u32),
394 					  fps);
395 		break;
396 	}
397 
398 	case PTRACE_SETFPREGS: {
399 		ret = copy_regset_from_user(child, &ptrace32_view,
400 					  REGSET_FP, 0,
401 					  33 * sizeof(u32),
402 					  fps);
403 		break;
404 	}
405 
406 	case PTRACE_READTEXT:
407 	case PTRACE_READDATA:
408 		ret = ptrace_readdata(child, addr, addr2p, data);
409 
410 		if (ret == data)
411 			ret = 0;
412 		else if (ret >= 0)
413 			ret = -EIO;
414 		break;
415 
416 	case PTRACE_WRITETEXT:
417 	case PTRACE_WRITEDATA:
418 		ret = ptrace_writedata(child, addr2p, addr, data);
419 
420 		if (ret == data)
421 			ret = 0;
422 		else if (ret >= 0)
423 			ret = -EIO;
424 		break;
425 
426 	default:
427 		if (request == PTRACE_SPARC_DETACH)
428 			request = PTRACE_DETACH;
429 		ret = ptrace_request(child, request, addr, data);
430 		break;
431 	}
432 
433 	return ret;
434 }
435 
syscall_trace(struct pt_regs * regs,int syscall_exit_p)436 asmlinkage int syscall_trace(struct pt_regs *regs, int syscall_exit_p)
437 {
438 	int ret = 0;
439 
440 	if (test_thread_flag(TIF_SYSCALL_TRACE)) {
441 		if (syscall_exit_p)
442 			ptrace_report_syscall_exit(regs, 0);
443 		else
444 			ret = ptrace_report_syscall_entry(regs);
445 	}
446 
447 	return ret;
448 }
449