[net-next-2.6.git] / arch / um / kernel / ptrace.c

/* 
 * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
 * Licensed under the GPL
 */

#include "linux/sched.h"
#include "linux/mm.h"
#include "linux/errno.h"
#include "linux/smp_lock.h"
#include "linux/security.h"
#include "linux/ptrace.h"
#include "linux/audit.h"
#ifdef CONFIG_PROC_MM
#include "linux/proc_mm.h"
#endif
#include "asm/ptrace.h"
#include "asm/uaccess.h"
#include "kern_util.h"
#include "skas_ptrace.h"
#include "sysdep/ptrace.h"

/*
 * Called by kernel/ptrace.c when detaching..
 */
void ptrace_disable(struct task_struct *child)
{ 
	child->ptrace &= ~PT_DTRACE;
	child->thread.singlestep_syscall = 0;
}

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

	lock_kernel();
	ret = -EPERM;
	if (request == PTRACE_TRACEME) {
		/* are we already being traced? */
		if (current->ptrace & PT_PTRACED)
			goto out;

		ret = security_ptrace(current->parent, current);
		if (ret)
 			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_tsk;

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

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

	switch (request) {
		/* when I and D space are separate, these will need to be fixed. */
	case PTRACE_PEEKTEXT: /* read word at location addr. */ 
	case PTRACE_PEEKDATA: {
		unsigned long tmp;
		int copied;

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

	/* read the word at location addr in the USER area. */
	case PTRACE_PEEKUSR: {
		unsigned long tmp;

		ret = -EIO;
		if ((addr & 3) || addr < 0) 
			break;

		tmp = 0;  /* Default return condition */
		if(addr < MAX_REG_OFFSET){
			tmp = getreg(child, addr);
		}
#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
		else if((addr >= offsetof(struct user, u_debugreg[0])) &&
			(addr <= offsetof(struct user, u_debugreg[7]))){
			addr -= offsetof(struct user, u_debugreg[0]);
			addr = addr >> 2;
			tmp = child->thread.arch.debugregs[addr];
		}
#endif
		ret = put_user(tmp, (unsigned long __user *) data);
		break;
	}

	/* when I and D space are separate, this will have to be fixed. */
	case PTRACE_POKETEXT: /* write the word at location addr. */
	case PTRACE_POKEDATA:
		ret = -EIO;
		if (access_process_vm(child, addr, &data, sizeof(data), 
				      1) != sizeof(data))
			break;
		ret = 0;
		break;

	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
		ret = -EIO;
		if ((addr & 3) || addr < 0)
			break;

		if (addr < MAX_REG_OFFSET) {
			ret = putreg(child, addr, data);
			break;
		}
#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
		else if((addr >= offsetof(struct user, u_debugreg[0])) &&
			(addr <= offsetof(struct user, u_debugreg[7]))){
			  addr -= offsetof(struct user, u_debugreg[0]);
			  addr = addr >> 2;
			  if((addr == 4) || (addr == 5)) break;
			  child->thread.arch.debugregs[addr] = data;
			  ret = 0;
		}
#endif

		break;

	case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
	case PTRACE_CONT: { /* restart after signal. */
		ret = -EIO;
		if (!valid_signal(data))
			break;

		child->ptrace &= ~PT_DTRACE;
		child->thread.singlestep_syscall = 0;
		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;
		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->exit_state == EXIT_ZOMBIE)	/* already dead */
			break;

		child->ptrace &= ~PT_DTRACE;
		child->thread.singlestep_syscall = 0;
		child->exit_code = SIGKILL;
		wake_up_process(child);
		break;
	}

	case PTRACE_SINGLESTEP: {  /* set the trap flag. */
		ret = -EIO;
		if (!valid_signal(data))
			break;
		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
		child->ptrace |= PT_DTRACE;
		child->thread.singlestep_syscall = 0;
		child->exit_code = data;
		/* give it a chance to run. */
		wake_up_process(child);
		ret = 0;
		break;
	}

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

#ifdef PTRACE_GETREGS
	case PTRACE_GETREGS: { /* Get all gp regs from the child. */
	  	if (!access_ok(VERIFY_WRITE, (unsigned long *)data, 
			       MAX_REG_OFFSET)) {
			ret = -EIO;
			break;
		}
		for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
			__put_user(getreg(child, i),
				   (unsigned long __user *) data);
			data += sizeof(long);
		}
		ret = 0;
		break;
	}
#endif
#ifdef PTRACE_SETREGS
	case PTRACE_SETREGS: { /* Set all gp regs in the child. */
		unsigned long tmp = 0;
	  	if (!access_ok(VERIFY_READ, (unsigned *)data, 
			       MAX_REG_OFFSET)) {
			ret = -EIO;
			break;
		}
		for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
			__get_user(tmp, (unsigned long __user *) data);
			putreg(child, i, tmp);
			data += sizeof(long);
		}
		ret = 0;
		break;
	}
#endif
#ifdef PTRACE_GETFPREGS
	case PTRACE_GETFPREGS: /* Get the child FPU state. */
		ret = get_fpregs(data, child);
		break;
#endif
#ifdef PTRACE_SETFPREGS
	case PTRACE_SETFPREGS: /* Set the child FPU state. */
	        ret = set_fpregs(data, child);
		break;
#endif
#ifdef PTRACE_GETFPXREGS
	case PTRACE_GETFPXREGS: /* Get the child FPU state. */
		ret = get_fpxregs(data, child);
		break;
#endif
#ifdef PTRACE_SETFPXREGS
	case PTRACE_SETFPXREGS: /* Set the child FPU state. */
		ret = set_fpxregs(data, child);
		break;
#endif
	case PTRACE_FAULTINFO: {
                /* Take the info from thread->arch->faultinfo,
                 * but transfer max. sizeof(struct ptrace_faultinfo).
                 * On i386, ptrace_faultinfo is smaller!
                 */
                ret = copy_to_user((unsigned long __user *) data,
                                   &child->thread.arch.faultinfo,
                                   sizeof(struct ptrace_faultinfo));
		if(ret)
			break;
		break;
	}
	case PTRACE_SIGPENDING:
		ret = copy_to_user((unsigned long __user *) data,
				   &child->pending.signal,
				   sizeof(child->pending.signal));
		break;

#ifdef PTRACE_LDT
	case PTRACE_LDT: {
		struct ptrace_ldt ldt;

		if(copy_from_user(&ldt, (unsigned long __user *) data,
				  sizeof(ldt))){
			ret = -EIO;
			break;
		}

		/* This one is confusing, so just punt and return -EIO for 
		 * now
		 */
		ret = -EIO;
		break;
	}
#endif
#ifdef CONFIG_PROC_MM
	case PTRACE_SWITCH_MM: {
		struct mm_struct *old = child->mm;
		struct mm_struct *new = proc_mm_get_mm(data);

		if(IS_ERR(new)){
			ret = PTR_ERR(new);
			break;
		}

		atomic_inc(&new->mm_users);
		child->mm = new;
		child->active_mm = new;
		mmput(old);
		ret = 0;
		break;
	}
#endif
	default:
		ret = ptrace_request(child, request, addr, data);
		break;
	}
 out_tsk:
	put_task_struct(child);
 out:
	unlock_kernel();
	return ret;
}

void send_sigtrap(struct task_struct *tsk, union uml_pt_regs *regs,
		  int error_code)
{
	struct siginfo info;

	memset(&info, 0, sizeof(info));
	info.si_signo = SIGTRAP;
	info.si_code = TRAP_BRKPT;

	/* User-mode eip? */
	info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;

	/* Send us the fakey SIGTRAP */
	force_sig_info(SIGTRAP, &info, tsk);
}

/* XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
 * PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
 */
void syscall_trace(union uml_pt_regs *regs, int entryexit)
{
	int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit;
	int tracesysgood;

	if (unlikely(current->audit_context)) {
		if (!entryexit)
			audit_syscall_entry(current,
                                            HOST_AUDIT_ARCH,
					    UPT_SYSCALL_NR(regs),
					    UPT_SYSCALL_ARG1(regs),
					    UPT_SYSCALL_ARG2(regs),
					    UPT_SYSCALL_ARG3(regs),
					    UPT_SYSCALL_ARG4(regs));
		else {
                        int res = UPT_SYSCALL_RET(regs);
			audit_syscall_exit(current, AUDITSC_RESULT(res),
                                           res);
                }
	}

	/* Fake a debug trap */
	if (is_singlestep)
		send_sigtrap(current, regs, 0);

	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 */
	tracesysgood = (current->ptrace & PT_TRACESYSGOOD);
	ptrace_notify(SIGTRAP | (tracesysgood ? 0x80 : 0));

	if (entryexit) /* force do_signal() --> is_syscall() */
		set_thread_flag(TIF_SIGPENDING);

	/* 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;
	}
}

/*
 * Overrides for Emacs so that we follow Linus's tabbing style.
 * Emacs will notice this stuff at the end of the file and automatically
 * adjust the settings for this buffer only.  This must remain at the end
 * of the file.
 * ---------------------------------------------------------------------------
 * Local variables:
 * c-file-style: "linux"
 * End:
 */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
	3	* Licensed under the GPL
	4	*/
	5
	6	#include "linux/sched.h"
	7	#include "linux/mm.h"
	8	#include "linux/errno.h"
	9	#include "linux/smp_lock.h"
	10	#include "linux/security.h"
	11	#include "linux/ptrace.h"
	12	#include "linux/audit.h"
	13	#ifdef CONFIG_PROC_MM
	14	#include "linux/proc_mm.h"
	15	#endif
	16	#include "asm/ptrace.h"
	17	#include "asm/uaccess.h"
	18	#include "kern_util.h"
	19	#include "skas_ptrace.h"
	20	#include "sysdep/ptrace.h"
	21
	22	/*
	23	* Called by kernel/ptrace.c when detaching..
	24	*/
	25	void ptrace_disable(struct task_struct *child)
	26	{
	27	child->ptrace &= ~PT_DTRACE;
	28	child->thread.singlestep_syscall = 0;
	29	}
	30
	31	long sys_ptrace(long request, long pid, long addr, long data)
	32	{
	33	struct task_struct *child;
	34	int i, ret;
	35
	36	lock_kernel();
	37	ret = -EPERM;
	38	if (request == PTRACE_TRACEME) {
	39	/* are we already being traced? */
	40	if (current->ptrace & PT_PTRACED)
	41	goto out;
	42
	43	ret = security_ptrace(current->parent, current);
	44	if (ret)
	45	goto out;
	46
	47	/* set the ptrace bit in the process flags. */
	48	current->ptrace \|= PT_PTRACED;
	49	ret = 0;
	50	goto out;
	51	}
	52	ret = -ESRCH;
	53	read_lock(&tasklist_lock);
	54	child = find_task_by_pid(pid);
	55	if (child)
	56	get_task_struct(child);
	57	read_unlock(&tasklist_lock);
	58	if (!child)
	59	goto out;
	60
	61	ret = -EPERM;
	62	if (pid == 1) /* you may not mess with init */
	63	goto out_tsk;
	64
65	if (request == PTRACE_ATTACH) {
66	ret = ptrace_attach(child);
67	goto out_tsk;
68	}
69
70	ret = ptrace_check_attach(child, request == PTRACE_KILL);
71	if (ret < 0)
72	goto out_tsk;
73
74	switch (request) {
75	/* when I and D space are separate, these will need to be fixed. */
76	case PTRACE_PEEKTEXT: /* read word at location addr. */
77	case PTRACE_PEEKDATA: {
78	unsigned long tmp;
79	int copied;
80
81	ret = -EIO;
82	copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
83	if (copied != sizeof(tmp))
84	break;
85	ret = put_user(tmp, (unsigned long __user *) data);
86	break;
87	}
88
89	/* read the word at location addr in the USER area. */
90	case PTRACE_PEEKUSR: {
91	unsigned long tmp;
92
93	ret = -EIO;
94	if ((addr & 3) \|\| addr < 0)
95	break;
96
97	tmp = 0; /* Default return condition */
98	if(addr < MAX_REG_OFFSET){
99	tmp = getreg(child, addr);
100	}
f7fe8781	101	#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
1da177e4 LT	102	else if((addr >= offsetof(struct user, u_debugreg[0])) &&
	103	(addr <= offsetof(struct user, u_debugreg[7]))){
	104	addr -= offsetof(struct user, u_debugreg[0]);
	105	addr = addr >> 2;
	106	tmp = child->thread.arch.debugregs[addr];
	107	}
f7fe8781	108	#endif
1da177e4 LT	109	ret = put_user(tmp, (unsigned long __user *) data);
	110	break;
	111	}
	112
	113	/* when I and D space are separate, this will have to be fixed. */
	114	case PTRACE_POKETEXT: /* write the word at location addr. */
	115	case PTRACE_POKEDATA:
	116	ret = -EIO;
	117	if (access_process_vm(child, addr, &data, sizeof(data),
	118	1) != sizeof(data))
	119	break;
	120	ret = 0;
	121	break;
	122
	123	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
	124	ret = -EIO;
	125	if ((addr & 3) \|\| addr < 0)
	126	break;
	127
	128	if (addr < MAX_REG_OFFSET) {
	129	ret = putreg(child, addr, data);
	130	break;
	131	}
f7fe8781	132	#if defined(CONFIG_UML_X86) && !defined(CONFIG_64BIT)
1da177e4 LT	133	else if((addr >= offsetof(struct user, u_debugreg[0])) &&
	134	(addr <= offsetof(struct user, u_debugreg[7]))){
	135	addr -= offsetof(struct user, u_debugreg[0]);
	136	addr = addr >> 2;
	137	if((addr == 4) \|\| (addr == 5)) break;
	138	child->thread.arch.debugregs[addr] = data;
	139	ret = 0;
	140	}
	141	#endif
	142
	143	break;
	144
	145	case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
	146	case PTRACE_CONT: { /* restart after signal. */
	147	ret = -EIO;
7ed20e1a	148	if (!valid_signal(data))
1da177e4 LT	149	break;
	150
	151	child->ptrace &= ~PT_DTRACE;
	152	child->thread.singlestep_syscall = 0;
	153	if (request == PTRACE_SYSCALL) {
	154	set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	155	}
	156	else {
	157	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	158	}
	159	child->exit_code = data;
	160	wake_up_process(child);
	161	ret = 0;
	162	break;
	163	}
	164
	165	/*
	166	* make the child exit. Best I can do is send it a sigkill.
	167	* perhaps it should be put in the status that it wants to
	168	* exit.
	169	*/
	170	case PTRACE_KILL: {
	171	ret = 0;
	172	if (child->exit_state == EXIT_ZOMBIE) /* already dead */
	173	break;
	174
	175	child->ptrace &= ~PT_DTRACE;
	176	child->thread.singlestep_syscall = 0;
	177	child->exit_code = SIGKILL;
	178	wake_up_process(child);
	179	break;
	180	}
	181
	182	case PTRACE_SINGLESTEP: { /* set the trap flag. */
	183	ret = -EIO;
7ed20e1a	184	if (!valid_signal(data))
1da177e4 LT	185	break;
	186	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
	187	child->ptrace \|= PT_DTRACE;
	188	child->thread.singlestep_syscall = 0;
	189	child->exit_code = data;
	190	/* give it a chance to run. */
	191	wake_up_process(child);
	192	ret = 0;
	193	break;
	194	}
	195
	196	case PTRACE_DETACH:
	197	/* detach a process that was attached. */
	198	ret = ptrace_detach(child, data);
	199	break;
	200
	201	#ifdef PTRACE_GETREGS
	202	case PTRACE_GETREGS: { /* Get all gp regs from the child. */
	203	if (!access_ok(VERIFY_WRITE, (unsigned long *)data,
	204	MAX_REG_OFFSET)) {
	205	ret = -EIO;
	206	break;
	207	}
	208	for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
	209	__put_user(getreg(child, i),
	210	(unsigned long __user *) data);
	211	data += sizeof(long);
	212	}
	213	ret = 0;
	214	break;
	215	}
	216	#endif
	217	#ifdef PTRACE_SETREGS
	218	case PTRACE_SETREGS: { /* Set all gp regs in the child. */
	219	unsigned long tmp = 0;
	220	if (!access_ok(VERIFY_READ, (unsigned *)data,
	221	MAX_REG_OFFSET)) {
	222	ret = -EIO;
	223	break;
	224	}
	225	for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) {
	226	__get_user(tmp, (unsigned long __user *) data);
	227	putreg(child, i, tmp);
	228	data += sizeof(long);
	229	}
	230	ret = 0;
	231	break;
	232	}
	233	#endif
	234	#ifdef PTRACE_GETFPREGS
	235	case PTRACE_GETFPREGS: /* Get the child FPU state. */
	236	ret = get_fpregs(data, child);
	237	break;
	238	#endif
	239	#ifdef PTRACE_SETFPREGS
	240	case PTRACE_SETFPREGS: /* Set the child FPU state. */
	241	ret = set_fpregs(data, child);
	242	break;
	243	#endif
	244	#ifdef PTRACE_GETFPXREGS
	245	case PTRACE_GETFPXREGS: /* Get the child FPU state. */
	246	ret = get_fpxregs(data, child);
	247	break;
	248	#endif
249	#ifdef PTRACE_SETFPXREGS
250	case PTRACE_SETFPXREGS: /* Set the child FPU state. */
251	ret = set_fpxregs(data, child);
252	break;
253	#endif
254	case PTRACE_FAULTINFO: {
c578455a BS	255	/* Take the info from thread->arch->faultinfo,
	256	* but transfer max. sizeof(struct ptrace_faultinfo).
	257	* On i386, ptrace_faultinfo is smaller!
	258	*/
	259	ret = copy_to_user((unsigned long __user *) data,
	260	&child->thread.arch.faultinfo,
	261	sizeof(struct ptrace_faultinfo));
1da177e4 LT	262	if(ret)
	263	break;
	264	break;
	265	}
	266	case PTRACE_SIGPENDING:
	267	ret = copy_to_user((unsigned long __user *) data,
	268	&child->pending.signal,
	269	sizeof(child->pending.signal));
	270	break;
	271
c578455a	272	#ifdef PTRACE_LDT
1da177e4 LT	273	case PTRACE_LDT: {
	274	struct ptrace_ldt ldt;
	275
	276	if(copy_from_user(&ldt, (unsigned long __user *) data,
	277	sizeof(ldt))){
	278	ret = -EIO;
	279	break;
	280	}
	281
	282	/* This one is confusing, so just punt and return -EIO for
	283	* now
	284	*/
	285	ret = -EIO;
	286	break;
	287	}
c578455a	288	#endif
1da177e4 LT	289	#ifdef CONFIG_PROC_MM
	290	case PTRACE_SWITCH_MM: {
	291	struct mm_struct *old = child->mm;
	292	struct mm_struct *new = proc_mm_get_mm(data);
	293
	294	if(IS_ERR(new)){
	295	ret = PTR_ERR(new);
	296	break;
	297	}
	298
	299	atomic_inc(&new->mm_users);
	300	child->mm = new;
	301	child->active_mm = new;
	302	mmput(old);
	303	ret = 0;
	304	break;
	305	}
	306	#endif
	307	default:
	308	ret = ptrace_request(child, request, addr, data);
	309	break;
	310	}
	311	out_tsk:
	312	put_task_struct(child);
	313	out:
	314	unlock_kernel();
	315	return ret;
	316	}
	317
	318	void send_sigtrap(struct task_struct tsk, union uml_pt_regs regs,
	319	int error_code)
	320	{
	321	struct siginfo info;
	322
	323	memset(&info, 0, sizeof(info));
	324	info.si_signo = SIGTRAP;
	325	info.si_code = TRAP_BRKPT;
	326
	327	/* User-mode eip? */
	328	info.si_addr = UPT_IS_USER(regs) ? (void __user *) UPT_IP(regs) : NULL;
	329
	330	/* Send us the fakey SIGTRAP */
	331	force_sig_info(SIGTRAP, &info, tsk);
	332	}
	333
	334	/* XXX Check PT_DTRACE vs TIF_SINGLESTEP for singlestepping check and
	335	* PT_PTRACED vs TIF_SYSCALL_TRACE for syscall tracing check
	336	*/
	337	void syscall_trace(union uml_pt_regs *regs, int entryexit)
	338	{
	339	int is_singlestep = (current->ptrace & PT_DTRACE) && entryexit;
	340	int tracesysgood;
	341
	342	if (unlikely(current->audit_context)) {
	343	if (!entryexit)
79d20b14 JD	344	audit_syscall_entry(current,
	345	HOST_AUDIT_ARCH,
	346	UPT_SYSCALL_NR(regs),
	347	UPT_SYSCALL_ARG1(regs),
	348	UPT_SYSCALL_ARG2(regs),
	349	UPT_SYSCALL_ARG3(regs),
	350	UPT_SYSCALL_ARG4(regs));
	351	else {
	352	int res = UPT_SYSCALL_RET(regs);
	353	audit_syscall_exit(current, AUDITSC_RESULT(res),
	354	res);
	355	}
1da177e4 LT	356	}
	357
	358	/* Fake a debug trap */
	359	if (is_singlestep)
	360	send_sigtrap(current, regs, 0);
	361
	362	if (!test_thread_flag(TIF_SYSCALL_TRACE))
	363	return;
	364
	365	if (!(current->ptrace & PT_PTRACED))
	366	return;
	367
	368	/* the 0x80 provides a way for the tracing parent to distinguish
	369	between a syscall stop and SIGTRAP delivery */
	370	tracesysgood = (current->ptrace & PT_TRACESYSGOOD);
	371	ptrace_notify(SIGTRAP \| (tracesysgood ? 0x80 : 0));
	372
	373	if (entryexit) /* force do_signal() --> is_syscall() */
	374	set_thread_flag(TIF_SIGPENDING);
	375
	376	/* this isn't the same as continuing with a signal, but it will do
	377	* for normal use. strace only continues with a signal if the
	378	* stopping signal is not SIGTRAP. -brl
	379	*/
	380	if (current->exit_code) {
	381	send_sig(current->exit_code, current, 1);
	382	current->exit_code = 0;
	383	}
	384	}
	385
	386	/*
	387	* Overrides for Emacs so that we follow Linus's tabbing style.
	388	* Emacs will notice this stuff at the end of the file and automatically
	389	* adjust the settings for this buffer only. This must remain at the end
	390	* of the file.
	391	* ---------------------------------------------------------------------------
	392	* Local variables:
	393	* c-file-style: "linux"
	394	* End:
	395	*/