patch-2.3.99-pre4 linux/arch/sh/kernel/ptrace.c

• Lines: 704
• Date: Mon Mar 27 10:26:15 2000
• Orig file: v2.3.99-pre3/linux/arch/sh/kernel/ptrace.c
• Orig date: Tue Sep 7 12:14:06 1999

diff -u --recursive --new-file v2.3.99-pre3/linux/arch/sh/kernel/ptrace.c linux/arch/sh/kernel/ptrace.c
@@ -1,6 +1,13 @@
-/*
- * Surely this doesn't work... (we need to design ptrace for SupreH)
+/* $Id: ptrace.c,v 1.4 2000/03/22 13:59:01 gniibe Exp $
+ *
  * linux/arch/sh/kernel/ptrace.c
+ *
+ * Original x86 implementation:
+ *	By Ross Biro 1/23/92
+ *	edited by Linus Torvalds
+ *
+ * SuperH version:   Copyright (C) 1999, 2000  Kaz Kojima & Niibe Yutaka
+ *
  */
 
 #include <linux/kernel.h>
@@ -12,135 +19,126 @@
 #include <linux/ptrace.h>
 #include <linux/user.h>
 
+#include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
 #include <asm/processor.h>
+#include <asm/mmu_context.h>
 
 /*
  * does not yet catch signals sent when the child dies.
  * in exit.c or in signal.c.
  */
 
-/* determines which flags the user has access to. */
-/* 1 = access 0 = no access */
-#define FLAG_MASK 0x00044dd5
-
-/* set's the trap flag. */
-#define TRAP_FLAG 0x100
-
 /*
- * Offset of eflags on child stack..
+ * This routine will get a word off of the process kernel stack.
  */
-#define EFL_OFFSET ((EFL-2)*4-sizeof(struct pt_regs))
-
-/*
- * this routine will get a word off of the processes privileged stack. 
- * the offset is how far from the base addr as stored in the TSS.  
- * this routine assumes that all the privileged stacks are in our
- * data space.
- */   
 static inline int get_stack_long(struct task_struct *task, int offset)
 {
 	unsigned char *stack;
 
-	stack = (unsigned char *)task->thread.sp;
+	stack = (unsigned char *)task + THREAD_SIZE - sizeof(struct pt_regs);
 	stack += offset;
 	return (*((int *)stack));
 }
 
 /*
- * this routine will put a word on the processes privileged stack. 
- * the offset is how far from the base addr as stored in the TSS.  
- * this routine assumes that all the privileged stacks are in our
- * data space.
+ * This routine will put a word on the process kernel stack.
  */
 static inline int put_stack_long(struct task_struct *task, int offset,
-	unsigned long data)
+				 unsigned long data)
 {
-	unsigned char * stack;
+	unsigned char *stack;
 
-	stack = (unsigned char *) task->thread.sp;
+	stack = (unsigned char *)task + THREAD_SIZE - sizeof(struct pt_regs);
 	stack += offset;
 	*(unsigned long *) stack = data;
 	return 0;
 }
 
-static int putreg(struct task_struct *child,
-	unsigned long regno, unsigned long value)
+static void
+compute_next_pc(struct pt_regs *regs, unsigned short inst,
+		unsigned long *pc1, unsigned long *pc2)
 {
-#if 0
-	switch (regno >> 2) {
-		case ORIG_EAX:
-			return -EIO;
-		case FS:
-			if (value && (value & 3) != 3)
-				return -EIO;
-			child->thread.fs = value;
-			return 0;
-		case GS:
-			if (value && (value & 3) != 3)
-				return -EIO;
-			child->thread.gs = value;
-			return 0;
-		case DS:
-		case ES:
-			if (value && (value & 3) != 3)
-				return -EIO;
-			value &= 0xffff;
-			break;
-		case SS:
-		case CS:
-			if ((value & 3) != 3)
-				return -EIO;
-			value &= 0xffff;
-			break;
-		case EFL:
-			value &= FLAG_MASK;
-			value |= get_stack_long(child, EFL_OFFSET) & ~FLAG_MASK;
-	}
-	if (regno > GS*4)
-		regno -= 2*4;
-	put_stack_long(child, regno - sizeof(struct pt_regs), value);
-#endif
-	return 0;
+	int nib[4]
+		= { (inst >> 12) & 0xf,
+		    (inst >> 8) & 0xf,
+		    (inst >> 4) & 0xf,
+		    inst & 0xf};
+
+	/* bra & bsr */
+	if (nib[0] == 0xa || nib[0] == 0xb) {
+		*pc1 = regs->pc + 4 + ((short) ((inst & 0xfff) << 4) >> 3);
+		*pc2 = (unsigned long) -1;
+		return;
+	}
+
+	/* bt & bf */
+	if (nib[0] == 0x8 && (nib[1] == 0x9 || nib[1] == 0xb)) {
+		*pc1 = regs->pc + 4 + ((char) (inst & 0xff) << 1);
+		*pc2 = regs->pc + 2;
+		return;
+	}
+
+	/* bt/s & bf/s */
+	if (nib[0] == 0x8 && (nib[1] == 0xd || nib[1] == 0xf)) {
+		*pc1 = regs->pc + 4 + ((char) (inst & 0xff) << 1);
+		*pc2 = regs->pc + 4;
+		return;
+	}
+
+	/* jmp & jsr */
+	if (nib[0] == 0x4 && nib[3] == 0xb
+	    && (nib[2] == 0x0 || nib[2] == 0x2)) {
+		*pc1 = regs->regs[nib[1]];
+		*pc2 = (unsigned long) -1;
+		return;
+	}
+
+	/* braf & bsrf */
+	if (nib[0] == 0x0 && nib[3] == 0x3
+	    && (nib[2] == 0x0 || nib[2] == 0x2)) {
+		*pc1 = regs->pc + 4 + regs->regs[nib[1]];
+		*pc2 = (unsigned long) -1;
+		return;
+	}
+
+	if (inst == 0x000b) {
+		*pc1 = regs->pr;
+		*pc2 = (unsigned long) -1;
+		return;
+	}
+
+	*pc1 = regs->pc + 2;
+	*pc2 = (unsigned long) -1;
+	return;
 }
 
-static unsigned long getreg(struct task_struct *child,
-	unsigned long regno)
+/* Tracing by user break controller.  */
+static void
+ubc_set_tracing(int asid, unsigned long nextpc1, unsigned nextpc2)
 {
-	unsigned long retval = ~0UL;
-
-#if 0
-	switch (regno >> 2) {
-		case FS:
-			retval = child->thread.fs;
-			break;
-		case GS:
-			retval = child->thread.gs;
-			break;
-		case DS:
-		case ES:
-		case SS:
-		case CS:
-			retval = 0xffff;
-			/* fall through */
-		default:
-			if (regno > GS*4)
-				regno -= 2*4;
-			regno = regno - sizeof(struct pt_regs);
-			retval &= get_stack_long(child, regno);
+	ctrl_outl(nextpc1, UBC_BARA);
+	ctrl_outb(asid, UBC_BASRA);
+	ctrl_outb(BAMR_12, UBC_BAMRA);
+	ctrl_outw(BBR_INST | BBR_READ, UBC_BBRA);
+
+	if (nextpc2 != (unsigned long) -1) {
+		ctrl_outl(nextpc2, UBC_BARB);
+		ctrl_outb(asid, UBC_BASRB);
+		ctrl_outb(BAMR_12, UBC_BAMRB);
+		ctrl_outw(BBR_INST | BBR_READ, UBC_BBRB);
 	}
-#endif
-	return retval;
+	ctrl_outw(BRCR_PCBA | BRCR_PCBB, UBC_BRCR);
 }
 
 asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
 {
-	struct task_struct *child;
+	struct task_struct *child, *tsk = current;
 	struct user * dummy = NULL;
 	unsigned long flags;
-	int i, ret;
+	int ret;
 
 	lock_kernel();
 	ret = -EPERM;
@@ -163,16 +161,16 @@
 	if (pid == 1)		/* you may not mess with init */
 		goto out;
 	if (request == PTRACE_ATTACH) {
-		if (child == current)
+		if (child == tsk)
 			goto out;
 		if ((!child->dumpable ||
-		    (current->uid != child->euid) ||
-		    (current->uid != child->suid) ||
-		    (current->uid != child->uid) ||
-	 	    (current->gid != child->egid) ||
-	 	    (current->gid != child->sgid) ||
-	 	    (!cap_issubset(child->cap_permitted, current->cap_permitted)) ||
-	 	    (current->gid != child->gid)) && !capable(CAP_SYS_PTRACE))
+		    (tsk->uid != child->euid) ||
+		    (tsk->uid != child->suid) ||
+		    (tsk->uid != child->uid) ||
+	 	    (tsk->gid != child->egid) ||
+	 	    (tsk->gid != child->sgid) ||
+	 	    (!cap_issubset(child->cap_permitted, tsk->cap_permitted)) ||
+	 	    (tsk->gid != child->gid)) && !capable(CAP_SYS_PTRACE))
 			goto out;
 		/* the same process cannot be attached many times */
 		if (child->flags & PF_PTRACED)
@@ -180,9 +178,9 @@
 		child->flags |= PF_PTRACED;
 
 		write_lock_irqsave(&tasklist_lock, flags);
-		if (child->p_pptr != current) {
+		if (child->p_pptr != tsk) {
 			REMOVE_LINKS(child);
-			child->p_pptr = current;
+			child->p_pptr = tsk;
 			SET_LINKS(child);
 		}
 		write_unlock_irqrestore(&tasklist_lock, flags);
@@ -198,257 +196,180 @@
 		if (request != PTRACE_KILL)
 			goto out;
 	}
-	if (child->p_pptr != current)
+	if (child->p_pptr != tsk)
 		goto out;
 
 	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;
-
-			copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
-			ret = -EIO;
-			if (copied != sizeof(tmp))
-				goto out;
-			ret = put_user(tmp,(unsigned long *) data);
-			goto out;
-		}
+	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);
+		break;
+	}
 
 	/* read the word at location addr in the USER area. */
-		case PTRACE_PEEKUSR: {
-			unsigned long tmp;
+	case PTRACE_PEEKUSR: {
+		unsigned long tmp;
 
-			ret = -EIO;
-			if ((addr & 3) || addr < 0 || 
-			    addr > sizeof(struct user) - 3)
-				goto out;
-
-			tmp = 0;  /* Default return condition */
-			if(addr < 17*sizeof(long))
-				tmp = getreg(child, addr);
-#if 0
-			if(addr >= (long) &dummy->u_debugreg[0] &&
-			   addr <= (long) &dummy->u_debugreg[7]){
-				addr -= (long) &dummy->u_debugreg[0];
-				addr = addr >> 2;
-				tmp = child->thread.debugreg[addr];
-			};
-#endif
-			ret = put_user(tmp,(unsigned long *) data);
-			goto out;
-		}
+		ret = -EIO;
+		if ((addr & 3) || addr < 0 || 
+		    addr > sizeof(struct user) - 3)
+			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 = 0;
-			if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
-				goto out;
-			ret = -EIO;
-			goto out;
+		if (addr < sizeof(struct pt_regs))
+			tmp = get_stack_long(child, addr);
+		else if (addr >= (long) &dummy->fpu &&
+			 addr < (long) &dummy->u_fpvalid) {
+			if (!child->used_math) {
+				if (addr == (long)&dummy->fpu.fpscr)
+					tmp = FPSCR_INIT;
+				else
+					tmp = 0;
+			} else
+				tmp = ((long *)&child->thread.fpu)
+					[(addr - (long)&dummy->fpu) >> 2];
+		} else if (addr == (long) &dummy->u_fpvalid)
+			tmp = child->used_math;
+		else
+			tmp = 0;
+		ret = put_user(tmp, (unsigned long *)data);
+		break;
+	}
 
-		case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
-			ret = -EIO;
-			if ((addr & 3) || addr < 0 || 
-			    addr > sizeof(struct user) - 3)
-				goto out;
-
-			if (addr < 17*sizeof(long)) {
-				ret = putreg(child, addr, data);
-				goto out;
-			}
-
-		  /* We need to be very careful here.  We implicitly
-		     want to modify a portion of the task_struct, and we
-		     have to be selective about what portions we allow someone
-		     to modify. */
-#if 0
-		  if(addr >= (long) &dummy->u_debugreg[0] &&
-		     addr <= (long) &dummy->u_debugreg[7]){
-
-			  if(addr == (long) &dummy->u_debugreg[4]) return -EIO;
-			  if(addr == (long) &dummy->u_debugreg[5]) return -EIO;
-			  if(addr < (long) &dummy->u_debugreg[4] &&
-			     ((unsigned long) data) >= TASK_SIZE-3) return -EIO;
-			  
-			  ret = -EIO;
-			  if(addr == (long) &dummy->u_debugreg[7]) {
-				  data &= ~DR_CONTROL_RESERVED;
-				  for(i=0; i<4; i++)
-					  if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
-						  goto out;
-			  };
-
-			  addr -= (long) &dummy->u_debugreg;
-			  addr = addr >> 2;
-			  child->thread.debugreg[addr] = data;
-			  ret = 0;
-			  goto out;
-		  };
-#endif
-		  ret = -EIO;
-		  goto out;
+	/* 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 = 0;
+		if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
+			break;
+		ret = -EIO;
+		break;
 
-		case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
-		case PTRACE_CONT: { /* restart after signal. */
-			long tmp;
-
-			ret = -EIO;
-			if ((unsigned long) data > _NSIG)
-				goto out;
-			if (request == PTRACE_SYSCALL)
-				child->flags |= PF_TRACESYS;
-			else
-				child->flags &= ~PF_TRACESYS;
-			child->exit_code = data;
-	/* make sure the single step bit is not set. */
-#if 0
-			tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
-			put_stack_long(child, EFL_OFFSET,tmp);
-#endif
-			wake_up_process(child);
+	case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
+		ret = -EIO;
+		if ((addr & 3) || addr < 0 || 
+		    addr > sizeof(struct user) - 3)
+			break;
+
+		if (addr < sizeof(struct pt_regs))
+			ret = put_stack_long(child, addr, data);
+		else if (addr >= (long) &dummy->fpu &&
+			 addr < (long) &dummy->u_fpvalid) {
+			child->used_math = 1;
+			((long *)&child->thread.fpu)
+				[(addr - (long)&dummy->fpu) >> 2] = data;
+			ret = 0;
+		} else if (addr == (long) &dummy->u_fpvalid) {
+			child->used_math = data?1:0;
 			ret = 0;
-			goto out;
 		}
+		break;
+
+	case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
+	case PTRACE_CONT: { /* restart after signal. */
+		ret = -EIO;
+		if ((unsigned long) data > _NSIG)
+			break;
+		if (request == PTRACE_SYSCALL)
+			child->flags |= PF_TRACESYS;
+		else
+			child->flags &= ~PF_TRACESYS;
+		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: {
-			long tmp;
+	case PTRACE_KILL: {
+		ret = 0;
+		if (child->state == TASK_ZOMBIE)	/* already dead */
+			break;
+		child->exit_code = SIGKILL;
+		wake_up_process(child);
+		break;
+	}
 
-			ret = 0;
-			if (child->state == TASK_ZOMBIE)	/* already dead */
-				goto out;
-			child->exit_code = SIGKILL;
-	/* make sure the single step bit is not set. */
-#if 0
-			tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
-			put_stack_long(child, EFL_OFFSET, tmp);
-#endif
-			wake_up_process(child);
-			goto out;
-		}
+	case PTRACE_SINGLESTEP: {  /* set the trap flag. */
+		long tmp, pc;
+		struct pt_regs *dummy = NULL;
+		struct pt_regs *regs;
+		unsigned long nextpc1, nextpc2;
+		unsigned short insn;
 
-		case PTRACE_SINGLESTEP: {  /* set the trap flag. */
-			long tmp;
+		ret = -EIO;
+		if ((unsigned long) data > _NSIG)
+			break;
+		child->flags &= ~PF_TRACESYS;
+		if ((child->flags & PF_DTRACE) == 0) {
+			/* Spurious delayed TF traps may occur */
+			child->flags |= PF_DTRACE;
+		}
 
-			ret = -EIO;
-			if ((unsigned long) data > _NSIG)
-				goto out;
-			child->flags &= ~PF_TRACESYS;
-			if ((child->flags & PF_DTRACE) == 0) {
-				/* Spurious delayed TF traps may occur */
-				child->flags |= PF_DTRACE;
-			}
-#if 0
-			tmp = get_stack_long(child, EFL_OFFSET) | TRAP_FLAG;
-			put_stack_long(child, EFL_OFFSET, tmp);
+		/* Compute next pc.  */
+		pc = get_stack_long(child, (long)&dummy->pc);
+		regs = (struct pt_regs *)((unsigned long)child + THREAD_SIZE - sizeof(struct pt_regs));
+		if (access_process_vm(child, pc&~3, &tmp, sizeof(tmp), 1) != sizeof(data))
+			break;
+ 
+#ifdef  __LITTLE_ENDIAN__
+		if (pc & 3)
+			insn = tmp >> 16;
+		else
+			insn = tmp & 0xffff;
+#else
+		if (pc & 3)
+			insn = tmp & 0xffff;
+		else
+			insn = tmp >> 16;
 #endif
-			child->exit_code = data;
-	/* give it a chance to run. */
-			wake_up_process(child);
-			ret = 0;
-			goto out;
-		}
+		compute_next_pc (regs, insn, &nextpc1, &nextpc2);
 
-		case PTRACE_DETACH: { /* detach a process that was attached. */
-			long tmp;
+		if (nextpc1 & 0x80000000)
+			break;
+		if (nextpc2 != (unsigned long) -1 && (nextpc2 & 0x80000000))
+			break;
 
-			ret = -EIO;
-			if ((unsigned long) data > _NSIG)
-				goto out;
-			child->flags &= ~(PF_PTRACED|PF_TRACESYS);
-			child->exit_code = data;
-			write_lock_irqsave(&tasklist_lock, flags);
-			REMOVE_LINKS(child);
-			child->p_pptr = child->p_opptr;
-			SET_LINKS(child);
-			write_unlock_irqrestore(&tasklist_lock, flags);
-	/* make sure the single step bit is not set. */
-#if 0
-			tmp = get_stack_long(child, EFL_OFFSET) & ~TRAP_FLAG;
-			put_stack_long(child, EFL_OFFSET, tmp);
-#endif
-			wake_up_process(child);
-			ret = 0;
-			goto out;
-		}
-#if 0
-		case PTRACE_GETREGS: { /* Get all gp regs from the child. */
-		  	if (!access_ok(VERIFY_WRITE, (unsigned *)data,
-				       17*sizeof(long)))
-			  {
-			    ret = -EIO;
-			    goto out;
-			  }
-			for ( i = 0; i < 17*sizeof(long); i += sizeof(long) )
-			  {
-			    __put_user(getreg(child, i),(unsigned long *) data);
-			    data += sizeof(long);
-			  }
-			ret = 0;
-			goto out;
-		  };
+		ubc_set_tracing(child->mm->context & MMU_CONTEXT_ASID_MASK,
+				nextpc1, nextpc2);
 
-		case PTRACE_SETREGS: { /* Set all gp regs in the child. */
-			unsigned long tmp;
-		  	if (!access_ok(VERIFY_READ, (unsigned *)data,
-				       17*sizeof(long)))
-			  {
-			    ret = -EIO;
-			    goto out;
-			  }
-			for ( i = 0; i < 17*sizeof(long); i += sizeof(long) )
-			  {
-			    __get_user(tmp, (unsigned long *) data);
-			    putreg(child, i, tmp);
-			    data += sizeof(long);
-			  }
-			ret = 0;
-			goto out;
-		  };
+		child->exit_code = data;
+		/* give it a chance to run. */
+		wake_up_process(child);
+		ret = 0;
+		break;
+	}
 
-		case PTRACE_GETFPREGS: { /* Get the child FPU state. */
-			if (!access_ok(VERIFY_WRITE, (unsigned *)data,
-				       sizeof(struct user_i387_struct)))
-			  {
-			    ret = -EIO;
-			    goto out;
-			  }
-			ret = 0;
-			if ( !child->used_math ) {
-			  /* Simulate an empty FPU. */
-			  child->thread.i387.hard.cwd = 0xffff037f;
-			  child->thread.i387.hard.swd = 0xffff0000;
-			  child->thread.i387.hard.twd = 0xffffffff;
-			}
-				__copy_to_user((void *)data, &child->thread.i387.hard,
-						sizeof(struct user_i387_struct));
-			goto out;
-		  };
+	case PTRACE_DETACH: { /* detach a process that was attached. */
+		ret = -EIO;
+		if ((unsigned long) data > _NSIG)
+			break;
+		child->flags &= ~(PF_PTRACED|PF_TRACESYS);
+		child->exit_code = data;
+		write_lock_irqsave(&tasklist_lock, flags);
+		REMOVE_LINKS(child);
+		child->p_pptr = child->p_opptr;
+		SET_LINKS(child);
+		write_unlock_irqrestore(&tasklist_lock, flags);
+		wake_up_process(child);
+		ret = 0;
+		break;
+	}
 
-		case PTRACE_SETFPREGS: { /* Set the child FPU state. */
-			if (!access_ok(VERIFY_READ, (unsigned *)data,
-				       sizeof(struct user_i387_struct)))
-			  {
-			    ret = -EIO;
-			    goto out;
-			  }
-			child->used_math = 1;
-			  __copy_from_user(&child->thread.i387.hard, (void *)data,
-					   sizeof(struct user_i387_struct));
-			ret = 0;
-			goto out;
-		  };
-#endif
-		default:
-			ret = -EIO;
-			goto out;
+	default:
+		ret = -EIO;
+		break;
 	}
 out:
 	unlock_kernel();
@@ -457,20 +378,22 @@
 
 asmlinkage void syscall_trace(void)
 {
-	if ((current->flags & (PF_PTRACED|PF_TRACESYS))
-			!= (PF_PTRACED|PF_TRACESYS))
+	struct task_struct *tsk = current;
+
+	if ((tsk->flags & (PF_PTRACED|PF_TRACESYS))
+	    != (PF_PTRACED|PF_TRACESYS))
 		return;
-	current->exit_code = SIGTRAP;
-	current->state = TASK_STOPPED;
-	notify_parent(current, SIGCHLD);
+	tsk->exit_code = SIGTRAP;
+	tsk->state = TASK_STOPPED;
+	notify_parent(tsk, SIGCHLD);
 	schedule();
 	/*
 	 * 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;
+	if (tsk->exit_code) {
+		send_sig(tsk->exit_code, tsk, 1);
+		tsk->exit_code = 0;
 	}
 }