if ((unsigned long) data > _NSIG) 
if (!valid_signal(data)) 
long sys_ptrace(long request, pid_t pid, long addr, long data){	struct task_struct *child;	long ret;#ifdef DEBUG_PTRACE	long oaddr=addr, odata=data;#endif	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)		/* no messing around 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) {	case PTRACE_PEEKTEXT: /* read word at location addr. */ 	case PTRACE_PEEKDATA: {		int copied;#ifdef __LP64__		if (is_compat_task(child)) {			unsigned int tmp;			addr &= 0xffffffffL;			copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);			ret = -EIO;			if (copied != sizeof(tmp))				goto out_tsk;			ret = put_user(tmp,(unsigned int *) data);			DBG("sys_ptrace(PEEK%s, %d, %lx, %lx) returning %ld, data %x\n",				request == PTRACE_PEEKTEXT ? "TEXT" : "DATA",				pid, oaddr, odata, ret, tmp);		}		else#endif		{			unsigned long tmp;			copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);			ret = -EIO;			if (copied != sizeof(tmp))				goto out_tsk;			ret = put_user(tmp,(unsigned long *) data);		}		goto out_tsk;	}	/* 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;#ifdef __LP64__		if (is_compat_task(child)) {			unsigned int tmp = (unsigned int)data;			DBG("sys_ptrace(POKE%s, %d, %lx, %lx)\n",				request == PTRACE_POKETEXT ? "TEXT" : "DATA",				pid, oaddr, odata);			addr &= 0xffffffffL;			if (access_process_vm(child, addr, &tmp, sizeof(tmp), 1) == sizeof(tmp))				goto out_tsk;		}		else#endif		{			if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))				goto out_tsk;		}		ret = -EIO;		goto out_tsk;	/* Read the word at location addr in the USER area.  For ptraced	   processes, the kernel saves all regs on a syscall. */	case PTRACE_PEEKUSR: {		ret = -EIO;#ifdef __LP64__		if (is_compat_task(child)) {			unsigned int tmp;			if (addr & (sizeof(int)-1))				goto out_tsk;			if ((addr = translate_usr_offset(addr)) < 0)				goto out_tsk;			tmp = *(unsigned int *) ((char *) task_regs(child) + addr);			ret = put_user(tmp, (unsigned int *) data);			DBG("sys_ptrace(PEEKUSR, %d, %lx, %lx) returning %ld, addr %lx, data %x\n",				pid, oaddr, odata, ret, addr, tmp);		}		else#endif		{			unsigned long tmp;			if ((addr & (sizeof(long)-1)) || (unsigned long) addr >= sizeof(struct pt_regs))				goto out_tsk;			tmp = *(unsigned long *) ((char *) task_regs(child) + addr);			ret = put_user(tmp, (unsigned long *) data);		}		goto out_tsk;	}	/* Write the word at location addr in the USER area.  This will need	   to change when the kernel no longer saves all regs on a syscall.	   FIXME.  There is a problem at the moment in that r3-r18 are only	   saved if the process is ptraced on syscall entry, and even then	   those values are overwritten by actual register values on syscall	   exit. */	case PTRACE_POKEUSR:		ret = -EIO;		/* Some register values written here may be ignored in		 * entry.S:syscall_restore_rfi; e.g. iaoq is written with		 * r31/r31+4, and not with the values in pt_regs.		 */		 /* PT_PSW=0, so this is valid for 32 bit processes under 64		 * bit kernels.		 */		if (addr == PT_PSW) {			/* PT_PSW=0, so this is valid for 32 bit processes			 * under 64 bit kernels.			 *			 * Allow writing to Nullify, Divide-step-correction,			 * and carry/borrow bits.			 * BEWARE, if you set N, and then single step, it won't			 * stop on the nullified instruction.			 */			DBG("sys_ptrace(POKEUSR, %d, %lx, %lx)\n",				pid, oaddr, odata);			data &= USER_PSW_BITS;			task_regs(child)->gr[0] &= ~USER_PSW_BITS;			task_regs(child)->gr[0] |= data;			ret = 0;			goto out_tsk;		}#ifdef __LP64__		if (is_compat_task(child)) {			if (addr & (sizeof(int)-1))				goto out_tsk;			if ((addr = translate_usr_offset(addr)) < 0)				goto out_tsk;			DBG("sys_ptrace(POKEUSR, %d, %lx, %lx) addr %lx\n",				pid, oaddr, odata, addr);			if (addr >= PT_FR0 && addr <= PT_FR31 + 4) {				/* Special case, fp regs are 64 bits anyway */				*(unsigned int *) ((char *) task_regs(child) + addr) = data;				ret = 0;			}			else if ((addr >= PT_GR1+4 && addr <= PT_GR31+4) ||					addr == PT_IAOQ0+4 || addr == PT_IAOQ1+4 ||					addr == PT_SAR+4) {				/* Zero the top 32 bits */				*(unsigned int *) ((char *) task_regs(child) + addr - 4) = 0;				*(unsigned int *) ((char *) task_regs(child) + addr) = data;				ret = 0;			}			goto out_tsk;		}		else#endif		{			if ((addr & (sizeof(long)-1)) || (unsigned long) addr >= sizeof(struct pt_regs))				goto out_tsk;			if ((addr >= PT_GR1 && addr <= PT_GR31) ||					addr == PT_IAOQ0 || addr == PT_IAOQ1 ||					(addr >= PT_FR0 && addr <= PT_FR31 + 4) ||					addr == PT_SAR) {				*(unsigned long *) ((char *) task_regs(child) + addr) = data;				ret = 0;			}			goto out_tsk;		}	case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */	case PTRACE_CONT:		ret = -EIO;		DBG("sys_ptrace(%s)\n",			request == PTRACE_SYSCALL ? "SYSCALL" : "CONT");		if ((unsigned long) data > _NSIG)			goto out_tsk;		child->ptrace &= ~(PT_SINGLESTEP|PT_BLOCKSTEP);		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;		goto out_wake_notrap;	case PTRACE_KILL:		/*		 * 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.		 */		DBG("sys_ptrace(KILL)\n");		if (child->exit_state == EXIT_ZOMBIE)	/* already dead */			goto out_tsk;		child->exit_code = SIGKILL;		goto out_wake_notrap;	case PTRACE_SINGLEBLOCK:		DBG("sys_ptrace(SINGLEBLOCK)\n");		ret = -EIO;		if ((unsigned long) data > _NSIG)			goto out_tsk;		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);		child->ptrace &= ~PT_SINGLESTEP;		child->ptrace |= PT_BLOCKSTEP;		child->exit_code = data;		/* Enable taken branch trap. */		pa_psw(child)->r = 0;		pa_psw(child)->t = 1;		pa_psw(child)->h = 0;		pa_psw(child)->l = 0;		goto out_wake;	case PTRACE_SINGLESTEP:		DBG("sys_ptrace(SINGLESTEP)\n");		ret = -EIO;		if ((unsigned long) data > _NSIG)			goto out_tsk;		clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);		child->ptrace &= ~PT_BLOCKSTEP;		child->ptrace |= PT_SINGLESTEP;		child->exit_code = data;		if (pa_psw(child)->n) {			struct siginfo si;			/* Nullified, just crank over the queue. */			task_regs(child)->iaoq[0] = task_regs(child)->iaoq[1];			task_regs(child)->iasq[0] = task_regs(child)->iasq[1];			task_regs(child)->iaoq[1] = task_regs(child)->iaoq[0] + 4;			pa_psw(child)->n = 0;			pa_psw(child)->x = 0;			pa_psw(child)->y = 0;			pa_psw(child)->z = 0;			pa_psw(child)->b = 0;			ptrace_disable(child);			/* Don't wake up the child, but let the			   parent know something happened. */			si.si_code = TRAP_TRACE;			si.si_addr = (void __user *) (task_regs(child)->iaoq[0] & ~3);			si.si_signo = SIGTRAP;			si.si_errno = 0;			force_sig_info(SIGTRAP, &si, child);			//notify_parent(child, SIGCHLD);			//ret = 0;			goto out_wake;		}		/* Enable recovery counter traps.  The recovery counter		 * itself will be set to zero on a task switch.  If the		 * task is suspended on a syscall then the syscall return		 * path will overwrite the recovery counter with a suitable		 * value such that it traps once back in user space.  We		 * disable interrupts in the childs PSW here also, to avoid		 * interrupts while the recovery counter is decrementing.		 */		pa_psw(child)->r = 1;		pa_psw(child)->t = 0;		pa_psw(child)->h = 0;		pa_psw(child)->l = 0;		/* give it a chance to run. */		goto out_wake;	case PTRACE_DETACH:		ret = ptrace_detach(child, data);		goto out_tsk;	case PTRACE_GETEVENTMSG:                ret = put_user(child->ptrace_message, (unsigned int __user *) data);		goto out_tsk;	default:		ret = ptrace_request(child, request, addr, data);		goto out_tsk;	}out_wake_notrap:	ptrace_disable(child);out_wake:	wake_up_process(child);	ret = 0;out_tsk:	put_task_struct(child);out:	unlock_kernel();	DBG("sys_ptrace(%ld, %d, %lx, %lx) returning %ld\n",		request, pid, oaddr, odata, ret);	return ret;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/7ed20e1ad521b5f5df61bf6559ae60738e393741/ptrace.c/clean/arch/parisc/kernel/ptrace.c