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 */
37void ptrace_disable(struct task_struct *child)
38{
39	/* nothing to do */
40}
41
42enum sparc_regset {
43	REGSET_GENERAL,
44	REGSET_FP,
45};
46
47static 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
65static 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
83static 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
106static 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
166static 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
182static 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
212static 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
244static 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
260static 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
287static 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
300static 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
323static 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
334static const struct user_regset_view ptrace32_view = {
335	.regsets = ptrace32_regsets, .n = ARRAY_SIZE(ptrace32_regsets)
336};
337
338static 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
343const struct user_regset_view *task_user_regset_view(struct task_struct *task)
344{
345	return &user_sparc32_view;
346}
347
348struct 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
360long 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
436asmlinkage 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