[mirror_ubuntu-bionic-kernel.git] / arch / xtensa / kernel / ptrace.c

// TODO some minor issues
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2001 - 2005  Tensilica Inc.
 *
 * Joe Taylor	<joe@tensilica.com, joetylr@yahoo.com>
 * Chris Zankel <chris@zankel.net>
 * Scott Foehner<sfoehner@yahoo.com>,
 * Kevin Chea
 * Marc Gauthier<marc@tensilica.com> <marc@alumni.uwaterloo.ca>
 */

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
#include <linux/security.h>

#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/ptrace.h>
#include <asm/elf.h>

#define TEST_KERNEL	// verify kernel operations FIXME: remove


/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure single step bits etc are not set.
 */

void ptrace_disable(struct task_struct *child)
{
	/* Nothing to do.. */
}

int sys_ptrace(long request, long pid, long addr, long data)
{
	struct task_struct *child;
	int ret = -EPERM;

	lock_kernel();

#if 0
	if ((int)request != 1)
	printk("ptrace(r=%d,pid=%d,addr=%08lx,data=%08lx)\n",
	       (int) request, (int) pid, (unsigned long) addr,
	       (unsigned long) data);
#endif

	if (request == PTRACE_TRACEME) {

		/* Are we already being traced? */

		if (current->ptrace & PT_PTRACED)
			goto out;

		if ((ret = security_ptrace(current->parent, current)))
			goto out;

		/* Set the ptrace bit in the process flags. */

		current->ptrace |= PT_PTRACED;
		ret = 0;
		goto out;
	}

	ret = -ESRCH;
	read_lock(&tasklist_lock);
	child = find_task_by_pid(pid);
	if (child)
		get_task_struct(child);
	read_unlock(&tasklist_lock);
	if (!child)
		goto out;

	ret = -EPERM;
	if (pid == 1)		/* you may not mess with init */
		goto out;

	if (request == PTRACE_ATTACH) {
		ret = ptrace_attach(child);
		goto out_tsk;
	}

	if ((ret = ptrace_check_attach(child, request == PTRACE_KILL)) < 0)
		goto out_tsk;

	switch (request) {
	case PTRACE_PEEKTEXT: /* read word at location addr. */
	case PTRACE_PEEKDATA:
	{
		unsigned long tmp;
		int copied;

		copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
		ret = -EIO;
		if (copied != sizeof(tmp))
			break;
		ret = put_user(tmp,(unsigned long *) data);

		goto out;
	}

	/* Read the word at location addr in the USER area.  */

	case PTRACE_PEEKUSR:
		{
		struct pt_regs *regs;
		unsigned long tmp;

		regs = xtensa_pt_regs(child);
		tmp = 0;  /* Default return value. */

		switch(addr) {

		case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
			{
			int ar = addr - REG_AR_BASE - regs->windowbase * 4;
			ar &= (XCHAL_NUM_AREGS - 1);
			if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
				tmp = regs->areg[ar];
			else
				ret = -EIO;
			break;
			}
		case REG_A_BASE ... REG_A_BASE + 15:
			tmp = regs->areg[addr - REG_A_BASE];
			break;
		case REG_PC:
			tmp = regs->pc;
			break;
		case REG_PS:
			/* Note:  PS.EXCM is not set while user task is running;
			 * its being set in regs is for exception handling
			 * convenience.  */
			tmp = (regs->ps & ~XCHAL_PS_EXCM_MASK);
			break;
		case REG_WB:
			tmp = regs->windowbase;
			break;
		case REG_WS:
			tmp = regs->windowstart;
			break;
		case REG_LBEG:
			tmp = regs->lbeg;
			break;
		case REG_LEND:
			tmp = regs->lend;
			break;
		case REG_LCOUNT:
			tmp = regs->lcount;
			break;
		case REG_SAR:
			tmp = regs->sar;
			break;
		case REG_DEPC:
			tmp = regs->depc;
			break;
		case REG_EXCCAUSE:
			tmp = regs->exccause;
			break;
		case REG_EXCVADDR:
			tmp = regs->excvaddr;
			break;
		case SYSCALL_NR:
			tmp = regs->syscall;
			break;
		default:
			tmp = 0;
			ret = -EIO;
			goto out;
		}
		ret = put_user(tmp, (unsigned long *) data);
		goto out;
		}

	case PTRACE_POKETEXT: /* write the word at location addr. */
	case PTRACE_POKEDATA:
		if (access_process_vm(child, addr, &data, sizeof(data), 1)
		    == sizeof(data))
			break;
		ret = -EIO;
		goto out;

	case PTRACE_POKEUSR:
		{
		struct pt_regs *regs;
		regs = xtensa_pt_regs(child);

		switch (addr) {
		case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
			{
			int ar = addr - REG_AR_BASE - regs->windowbase * 4;
			if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
				regs->areg[ar & (XCHAL_NUM_AREGS - 1)] = data;
			else
				ret = -EIO;
			break;
			}
		case REG_A_BASE ... REG_A_BASE + 15:
			regs->areg[addr - REG_A_BASE] = data;
			break;
		case REG_PC:
			regs->pc = data;
			break;
		case SYSCALL_NR:
			regs->syscall = data;
			break;
#ifdef TEST_KERNEL
		case REG_WB:
			regs->windowbase = data;
			break;
		case REG_WS:
			regs->windowstart = data;
			break;
#endif

		default:
			/* The rest are not allowed. */
			ret = -EIO;
			break;
		}
		break;
		}

	/* continue and stop at next (return from) syscall */
	case PTRACE_SYSCALL:
	case PTRACE_CONT: /* restart after signal. */
	{
		ret = -EIO;
		if ((unsigned long) data > _NSIG)
			break;
		if (request == PTRACE_SYSCALL)
			set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		else
			clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		child->exit_code = data;
		/* Make sure the single step bit is not set. */
		child->ptrace &= ~PT_SINGLESTEP;
		wake_up_process(child);
		ret = 0;
		break;
	}

	/*
	 * make the child exit.  Best I can do is send it a sigkill.
	 * perhaps it should be put in the status that it wants to
	 * exit.
	 */
	case PTRACE_KILL:
		ret = 0;
		if (child->state == EXIT_ZOMBIE)	/* already dead */
			break;
		child->exit_code = SIGKILL;
		child->ptrace &= ~PT_SINGLESTEP;
		wake_up_process(child);
		break;

	case PTRACE_SINGLESTEP:
		ret = -EIO;
		if ((unsigned long) data > _NSIG)
			break;
		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		child->ptrace |= PT_SINGLESTEP;
		child->exit_code = data;
		wake_up_process(child);
		ret = 0;
		break;

	case PTRACE_GETREGS:
	{
		/* 'data' points to user memory in which to write.
		 * Mainly due to the non-live register values, we
		 * reformat the register values into something more
		 * standard.  For convenience, we use the handy
		 * elf_gregset_t format. */

		xtensa_gregset_t format;
		struct pt_regs *regs = xtensa_pt_regs(child);

		do_copy_regs (&format, regs, child);

		/* Now, copy to user space nice and easy... */
		ret = 0;
		if (copy_to_user((void *)data, &format, sizeof(elf_gregset_t)))
			ret = -EFAULT;
		break;
	}

	case PTRACE_SETREGS:
	{
		/* 'data' points to user memory that contains the new
		 * values in the elf_gregset_t format. */

		xtensa_gregset_t format;
		struct pt_regs *regs = xtensa_pt_regs(child);

		if (copy_from_user(&format,(void *)data,sizeof(elf_gregset_t))){
			ret = -EFAULT;
			break;
		}

		/* FIXME: Perhaps we want some sanity checks on
		 * these user-space values?  See ARM version.  Are
		 * debuggers a security concern? */

		do_restore_regs (&format, regs, child);

		ret = 0;
		break;
	}

	case PTRACE_GETFPREGS:
	{
		/* 'data' points to user memory in which to write.
		 * For convenience, we use the handy
		 * elf_fpregset_t format. */

		elf_fpregset_t fpregs;
		struct pt_regs *regs = xtensa_pt_regs(child);

		do_save_fpregs (&fpregs, regs, child);

		/* Now, copy to user space nice and easy... */
		ret = 0;
		if (copy_to_user((void *)data, &fpregs, sizeof(elf_fpregset_t)))
			ret = -EFAULT;

		break;
	}

	case PTRACE_SETFPREGS:
	{
		/* 'data' points to user memory that contains the new
		 * values in the elf_fpregset_t format.
		 */
		elf_fpregset_t fpregs;
		struct pt_regs *regs = xtensa_pt_regs(child);

		ret = 0;
		if (copy_from_user(&fpregs, (void *)data, sizeof(elf_fpregset_t))) {
			ret = -EFAULT;
			break;
		}

		if (do_restore_fpregs (&fpregs, regs, child))
			ret = -EIO;
		break;
	}

	case PTRACE_GETFPREGSIZE:
		/* 'data' points to 'unsigned long' set to the size
		 * of elf_fpregset_t
		 */
		ret = put_user(sizeof(elf_fpregset_t), (unsigned long *) data);
		break;

	case PTRACE_DETACH: /* detach a process that was attached. */
		ret = ptrace_detach(child, data);
		break;

	default:
		ret = ptrace_request(child, request, addr, data);
		goto out;
	}
out_tsk:
	put_task_struct(child);
out:
	unlock_kernel();
	return ret;
}

void do_syscall_trace(void)
{
	if (!test_thread_flag(TIF_SYSCALL_TRACE))
		return;

	if (!(current->ptrace & PT_PTRACED))
		return;

	/*
	 * The 0x80 provides a way for the tracing parent to distinguish
	 * between a syscall stop and SIGTRAP delivery
	 */
	ptrace_notify(SIGTRAP|((current->ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));

	/*
	 * this isn't the same as continuing with a signal, but it will do
	 * for normal use.  strace only continues with a signal if the
	 * stopping signal is not SIGTRAP.  -brl
	 */
	if (current->exit_code) {
		send_sig(current->exit_code, current, 1);
		current->exit_code = 0;
	}
}
Commit	Line	Data
5a0015d6 CZ	1	// TODO some minor issues
	2	/*
	3	* This file is subject to the terms and conditions of the GNU General Public
	4	* License. See the file "COPYING" in the main directory of this archive
	5	* for more details.
	6	*
	7	* Copyright (C) 2001 - 2005 Tensilica Inc.
	8	*
	9	* Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
	10	* Chris Zankel <chris@zankel.net>
	11	* Scott Foehner<sfoehner@yahoo.com>,
	12	* Kevin Chea
	13	* Marc Gauthier<marc@tensilica.com> <marc@alumni.uwaterloo.ca>
	14	*/
	15
	16	#include <linux/config.h>
	17	#include <linux/kernel.h>
	18	#include <linux/sched.h>
	19	#include <linux/mm.h>
	20	#include <linux/errno.h>
	21	#include <linux/ptrace.h>
	22	#include <linux/smp.h>
	23	#include <linux/smp_lock.h>
	24	#include <linux/security.h>
	25
	26	#include <asm/pgtable.h>
	27	#include <asm/page.h>
	28	#include <asm/system.h>
	29	#include <asm/uaccess.h>
	30	#include <asm/ptrace.h>
	31	#include <asm/elf.h>
	32
	33	#define TEST_KERNEL // verify kernel operations FIXME: remove
	34
	35
	36	/*
	37	* Called by kernel/ptrace.c when detaching..
	38	*
	39	* Make sure single step bits etc are not set.
	40	*/
	41
	42	void ptrace_disable(struct task_struct *child)
	43	{
	44	/* Nothing to do.. */
	45	}
	46
	47	int sys_ptrace(long request, long pid, long addr, long data)
	48	{
	49	struct task_struct *child;
	50	int ret = -EPERM;
	51
	52	lock_kernel();
	53
	54	#if 0
	55	if ((int)request != 1)
	56	printk("ptrace(r=%d,pid=%d,addr=%08lx,data=%08lx)\n",
	57	(int) request, (int) pid, (unsigned long) addr,
	58	(unsigned long) data);
	59	#endif
	60
	61	if (request == PTRACE_TRACEME) {
	62
	63	/* Are we already being traced? */
	64
65	if (current->ptrace & PT_PTRACED)
66	goto out;
67
68	if ((ret = security_ptrace(current->parent, current)))
69	goto out;
70
71	/* Set the ptrace bit in the process flags. */
72
73	current->ptrace \|= PT_PTRACED;
74	ret = 0;
75	goto out;
76	}
77
78	ret = -ESRCH;
79	read_lock(&tasklist_lock);
80	child = find_task_by_pid(pid);
81	if (child)
82	get_task_struct(child);
83	read_unlock(&tasklist_lock);
84	if (!child)
85	goto out;
86
87	ret = -EPERM;
88	if (pid == 1) /* you may not mess with init */
89	goto out;
90
91	if (request == PTRACE_ATTACH) {
92	ret = ptrace_attach(child);
93	goto out_tsk;
94	}
95
96	if ((ret = ptrace_check_attach(child, request == PTRACE_KILL)) < 0)
97	goto out_tsk;
98
99	switch (request) {
100	case PTRACE_PEEKTEXT: /* read word at location addr. */
101	case PTRACE_PEEKDATA:
102	{
103	unsigned long tmp;
104	int copied;
105
106	copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
107	ret = -EIO;
108	if (copied != sizeof(tmp))
109	break;
110	ret = put_user(tmp,(unsigned long *) data);
111
112	goto out;
113	}
114
115	/* Read the word at location addr in the USER area. */
116
117	case PTRACE_PEEKUSR:
118	{
119	struct pt_regs *regs;
120	unsigned long tmp;
121
122	regs = xtensa_pt_regs(child);
123	tmp = 0; /* Default return value. */
124
125	switch(addr) {
126
127	case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
128	{
129	int ar = addr - REG_AR_BASE - regs->windowbase * 4;
130	ar &= (XCHAL_NUM_AREGS - 1);
131	if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
132	tmp = regs->areg[ar];
133	else
134	ret = -EIO;
135	break;
136	}
137	case REG_A_BASE ... REG_A_BASE + 15:
138	tmp = regs->areg[addr - REG_A_BASE];
139	break;
140	case REG_PC:
141	tmp = regs->pc;
142	break;
143	case REG_PS:
144	/* Note: PS.EXCM is not set while user task is running;
145	* its being set in regs is for exception handling
146	* convenience. */
147	tmp = (regs->ps & ~XCHAL_PS_EXCM_MASK);
148	break;
149	case REG_WB:
150	tmp = regs->windowbase;
151	break;
152	case REG_WS:
153	tmp = regs->windowstart;
154	break;
155	case REG_LBEG:
156	tmp = regs->lbeg;
157	break;
158	case REG_LEND:
159	tmp = regs->lend;
160	break;
161	case REG_LCOUNT:
162	tmp = regs->lcount;
163	break;
164	case REG_SAR:
165	tmp = regs->sar;
166	break;
167	case REG_DEPC:
168	tmp = regs->depc;
169	break;
170	case REG_EXCCAUSE:
171	tmp = regs->exccause;
172	break;
173	case REG_EXCVADDR:
174	tmp = regs->excvaddr;
175	break;
176	case SYSCALL_NR:
177	tmp = regs->syscall;
178	break;
179	default:
180	tmp = 0;
181	ret = -EIO;
182	goto out;
183	}
184	ret = put_user(tmp, (unsigned long *) data);
185	goto out;
186	}
187
188	case PTRACE_POKETEXT: /* write the word at location addr. */
189	case PTRACE_POKEDATA:
190	if (access_process_vm(child, addr, &data, sizeof(data), 1)
191	== sizeof(data))
192	break;
193	ret = -EIO;
194	goto out;
195
196	case PTRACE_POKEUSR:
197	{
198	struct pt_regs *regs;
199	regs = xtensa_pt_regs(child);
200
201	switch (addr) {
202	case REG_AR_BASE ... REG_AR_BASE + XCHAL_NUM_AREGS - 1:
203	{
204	int ar = addr - REG_AR_BASE - regs->windowbase * 4;
205	if (ar < 16 && ar + (regs->wmask >> 4) * 4 >= 0)
206	regs->areg[ar & (XCHAL_NUM_AREGS - 1)] = data;
207	else
208	ret = -EIO;
209	break;
210	}
211	case REG_A_BASE ... REG_A_BASE + 15:
212	regs->areg[addr - REG_A_BASE] = data;
213	break;
214	case REG_PC:
215	regs->pc = data;
216	break;
217	case SYSCALL_NR:
218	regs->syscall = data;
219	break;
220	#ifdef TEST_KERNEL
221	case REG_WB:
222	regs->windowbase = data;
223	break;
224	case REG_WS:
225	regs->windowstart = data;
226	break;
227	#endif
228
229	default:
230	/* The rest are not allowed. */
231	ret = -EIO;
232	break;
233	}
234	break;
235	}
236
237	/* continue and stop at next (return from) syscall */
238	case PTRACE_SYSCALL:
239	case PTRACE_CONT: /* restart after signal. */
240	{
241	ret = -EIO;
242	if ((unsigned long) data > _NSIG)
243	break;
244	if (request == PTRACE_SYSCALL)
245	set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
246	else
247	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
248	child->exit_code = data;
249	/* Make sure the single step bit is not set. */
250	child->ptrace &= ~PT_SINGLESTEP;
251	wake_up_process(child);
252	ret = 0;
253	break;
254	}
255
256	/*
257	* make the child exit. Best I can do is send it a sigkill.
258	* perhaps it should be put in the status that it wants to
259	* exit.
260	*/
261	case PTRACE_KILL:
262	ret = 0;
263	if (child->state == EXIT_ZOMBIE) /* already dead */
264	break;
265	child->exit_code = SIGKILL;
266	child->ptrace &= ~PT_SINGLESTEP;
267	wake_up_process(child);
268	break;
269
270	case PTRACE_SINGLESTEP:
271	ret = -EIO;
272	if ((unsigned long) data > _NSIG)
273	break;
274	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
275	child->ptrace \|= PT_SINGLESTEP;
276	child->exit_code = data;
277	wake_up_process(child);
278	ret = 0;
279	break;
280
281	case PTRACE_GETREGS:
282	{
283	/* 'data' points to user memory in which to write.
284	* Mainly due to the non-live register values, we
285	* reformat the register values into something more
286	* standard. For convenience, we use the handy
287	* elf_gregset_t format. */
288
289	xtensa_gregset_t format;
290	struct pt_regs *regs = xtensa_pt_regs(child);
291
292	do_copy_regs (&format, regs, child);
293
294	/* Now, copy to user space nice and easy... */
295	ret = 0;
296	if (copy_to_user((void *)data, &format, sizeof(elf_gregset_t)))
297	ret = -EFAULT;
298	break;
299	}
300
301	case PTRACE_SETREGS:
302	{
303	/* 'data' points to user memory that contains the new
304	* values in the elf_gregset_t format. */
305
306	xtensa_gregset_t format;
307	struct pt_regs *regs = xtensa_pt_regs(child);
308
309	if (copy_from_user(&format,(void *)data,sizeof(elf_gregset_t))){
310	ret = -EFAULT;
311	break;
312	}
313
314	/* FIXME: Perhaps we want some sanity checks on
315	* these user-space values? See ARM version. Are
316	* debuggers a security concern? */
317
318	do_restore_regs (&format, regs, child);
319
320	ret = 0;
321	break;
322	}
323
324	case PTRACE_GETFPREGS:
325	{
326	/* 'data' points to user memory in which to write.
327	* For convenience, we use the handy
328	* elf_fpregset_t format. */
329
330	elf_fpregset_t fpregs;
331	struct pt_regs *regs = xtensa_pt_regs(child);
332
333	do_save_fpregs (&fpregs, regs, child);
334
335	/* Now, copy to user space nice and easy... */
336	ret = 0;
337	if (copy_to_user((void *)data, &fpregs, sizeof(elf_fpregset_t)))
338	ret = -EFAULT;
339
340	break;
341	}
342
343	case PTRACE_SETFPREGS:
344	{
345	/* 'data' points to user memory that contains the new
346	* values in the elf_fpregset_t format.
347	*/
348	elf_fpregset_t fpregs;
349	struct pt_regs *regs = xtensa_pt_regs(child);
350
351	ret = 0;
352	if (copy_from_user(&fpregs, (void *)data, sizeof(elf_fpregset_t))) {
353	ret = -EFAULT;
354	break;
355	}
356
357	if (do_restore_fpregs (&fpregs, regs, child))
358	ret = -EIO;
359	break;
360	}
361
362	case PTRACE_GETFPREGSIZE:
363	/* 'data' points to 'unsigned long' set to the size
364	* of elf_fpregset_t
365	*/
366	ret = put_user(sizeof(elf_fpregset_t), (unsigned long *) data);
367	break;
368
369	case PTRACE_DETACH: /* detach a process that was attached. */
370	ret = ptrace_detach(child, data);
371	break;
372
373	default:
374	ret = ptrace_request(child, request, addr, data);
375	goto out;
376	}
377	out_tsk:
378	put_task_struct(child);
379	out:
380	unlock_kernel();
381	return ret;
382	}
383
384	void do_syscall_trace(void)
385	{
386	if (!test_thread_flag(TIF_SYSCALL_TRACE))
387	return;
388
389	if (!(current->ptrace & PT_PTRACED))
390	return;
391
392	/*
393	* The 0x80 provides a way for the tracing parent to distinguish
394	* between a syscall stop and SIGTRAP delivery
395	*/
396	ptrace_notify(SIGTRAP\|((current->ptrace & PT_TRACESYSGOOD) ? 0x80 : 0));
397
398	/*
399	* this isn't the same as continuing with a signal, but it will do
400	* for normal use. strace only continues with a signal if the
401	* stopping signal is not SIGTRAP. -brl
402	*/
403	if (current->exit_code) {
404	send_sig(current->exit_code, current, 1);
405	current->exit_code = 0;
406	}
407	}