自学教程：C++ test_thread_flag函数代码示例

static int watchpoint_handler(unsigned long addr, unsigned int esr,			      struct pt_regs *regs){	int i, step = 0, *kernel_step, access;	u32 ctrl_reg;	u64 val, alignment_mask;	struct perf_event *wp, **slots;	struct debug_info *debug_info;	struct arch_hw_breakpoint *info;	struct arch_hw_breakpoint_ctrl ctrl;	slots = this_cpu_ptr(wp_on_reg);	debug_info = &current->thread.debug;	for (i = 0; i < core_num_wrps; ++i) {		rcu_read_lock();		wp = slots[i];		if (wp == NULL)			goto unlock;		info = counter_arch_bp(wp);		/* AArch32 watchpoints are either 4 or 8 bytes aligned. */		if (is_compat_task()) {			if (info->ctrl.len == ARM_BREAKPOINT_LEN_8)				alignment_mask = 0x7;			else				alignment_mask = 0x3;		} else {			alignment_mask = 0x7;		}		/* Check if the watchpoint value matches. */		val = read_wb_reg(AARCH64_DBG_REG_WVR, i);		if (val != (addr & ~alignment_mask))			goto unlock;		/* Possible match, check the byte address select to confirm. */		ctrl_reg = read_wb_reg(AARCH64_DBG_REG_WCR, i);		decode_ctrl_reg(ctrl_reg, &ctrl);		if (!((1 << (addr & alignment_mask)) & ctrl.len))			goto unlock;		/*		 * Check that the access type matches.		 * 0 => load, otherwise => store		 */		access = (esr & AARCH64_ESR_ACCESS_MASK) ? HW_BREAKPOINT_W :			 HW_BREAKPOINT_R;		if (!(access & hw_breakpoint_type(wp)))			goto unlock;		info->trigger = addr;		perf_bp_event(wp, regs);		/* Do we need to handle the stepping? */		if (!wp->overflow_handler)			step = 1;unlock:		rcu_read_unlock();	}	if (!step)		return 0;	/*	 * We always disable EL0 watchpoints because the kernel can	 * cause these to fire via an unprivileged access.	 */	toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL0, 0);	if (user_mode(regs)) {		debug_info->wps_disabled = 1;		/* If we're already stepping a breakpoint, just return. */		if (debug_info->bps_disabled)			return 0;		if (test_thread_flag(TIF_SINGLESTEP))			debug_info->suspended_step = 1;		else			user_enable_single_step(current);	} else {		toggle_bp_registers(AARCH64_DBG_REG_WCR, DBG_ACTIVE_EL1, 0);		kernel_step = this_cpu_ptr(&stepping_kernel_bp);		if (*kernel_step != ARM_KERNEL_STEP_NONE)			return 0;		if (kernel_active_single_step()) {			*kernel_step = ARM_KERNEL_STEP_SUSPEND;		} else {			*kernel_step = ARM_KERNEL_STEP_ACTIVE;			kernel_enable_single_step(regs);		}	}	return 0;//.........这里部分代码省略.........

unsigned longarch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,			  const unsigned long len, const unsigned long pgoff,			  const unsigned long flags){	struct vm_area_struct *vma;	struct mm_struct *mm = current->mm;	unsigned long task_size = STACK_TOP32;	unsigned long addr = addr0;	int do_color_align;	/* This should only ever run for 32-bit processes.  */	BUG_ON(!test_thread_flag(TIF_32BIT));	if (flags & MAP_FIXED) {		/* We do not accept a shared mapping if it would violate		 * cache aliasing constraints.		 */		if ((flags & MAP_SHARED) &&		    ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))			return -EINVAL;		return addr;	}	if (unlikely(len > task_size))		return -ENOMEM;	do_color_align = 0;	if (filp || (flags & MAP_SHARED))		do_color_align = 1;	/* requesting a specific address */	if (addr) {		if (do_color_align)			addr = COLOUR_ALIGN(addr, pgoff);		else			addr = PAGE_ALIGN(addr);		vma = find_vma(mm, addr);		if (task_size - len >= addr &&		    (!vma || addr + len <= vma->vm_start))			return addr;	}	/* check if free_area_cache is useful for us */	if (len <= mm->cached_hole_size) { 	        mm->cached_hole_size = 0; 		mm->free_area_cache = mm->mmap_base; 	}	/* either no address requested or can't fit in requested address hole */	addr = mm->free_area_cache;	if (do_color_align) {		unsigned long base = COLOUR_ALIGN_DOWN(addr-len, pgoff);		addr = base + len;	}	/* make sure it can fit in the remaining address space */	if (likely(addr > len)) {		vma = find_vma(mm, addr-len);		if (!vma || addr <= vma->vm_start) {			/* remember the address as a hint for next time */			return (mm->free_area_cache = addr-len);		}	}	if (unlikely(mm->mmap_base < len))		goto bottomup;	addr = mm->mmap_base-len;	if (do_color_align)		addr = COLOUR_ALIGN_DOWN(addr, pgoff);	do {		/*		 * Lookup failure means no vma is above this address,		 * else if new region fits below vma->vm_start,		 * return with success:		 */		vma = find_vma(mm, addr);		if (likely(!vma || addr+len <= vma->vm_start)) {			/* remember the address as a hint for next time */			return (mm->free_area_cache = addr);		} 		/* remember the largest hole we saw so far */ 		if (addr + mm->cached_hole_size < vma->vm_start) 		        mm->cached_hole_size = vma->vm_start - addr;		/* try just below the current vma->vm_start */		addr = vma->vm_start-len;		if (do_color_align)			addr = COLOUR_ALIGN_DOWN(addr, pgoff);	} while (likely(len < vma->vm_start));bottomup:	/*	 * A failed mmap() very likely causes application failure,	 * so fall back to the bottom-up function here. This scenario//.........这里部分代码省略.........

/* * Returns the syscall nr to run (which should match regs->orig_ax) or -1 * to skip the syscall. */static long syscall_trace_enter(struct pt_regs *regs){	u32 arch = in_ia32_syscall() ? AUDIT_ARCH_I386 : AUDIT_ARCH_X86_64;	struct thread_info *ti = current_thread_info();	unsigned long ret = 0;	bool emulated = false;	u32 work;	if (IS_ENABLED(CONFIG_DEBUG_ENTRY))		BUG_ON(regs != task_pt_regs(current));	work = READ_ONCE(ti->flags) & _TIF_WORK_SYSCALL_ENTRY;	if (unlikely(work & _TIF_SYSCALL_EMU))		emulated = true;	if ((emulated || (work & _TIF_SYSCALL_TRACE)) &&	    tracehook_report_syscall_entry(regs))		return -1L;	if (emulated)		return -1L;#ifdef CONFIG_SECCOMP	/*	 * Do seccomp after ptrace, to catch any tracer changes.	 */	if (work & _TIF_SECCOMP) {		struct seccomp_data sd;		sd.arch = arch;		sd.nr = regs->orig_ax;		sd.instruction_pointer = regs->ip;#ifdef CONFIG_X86_64		if (arch == AUDIT_ARCH_X86_64) {			sd.args[0] = regs->di;			sd.args[1] = regs->si;			sd.args[2] = regs->dx;			sd.args[3] = regs->r10;			sd.args[4] = regs->r8;			sd.args[5] = regs->r9;		} else#endif		{			sd.args[0] = regs->bx;			sd.args[1] = regs->cx;			sd.args[2] = regs->dx;			sd.args[3] = regs->si;			sd.args[4] = regs->di;			sd.args[5] = regs->bp;		}		ret = __secure_computing(&sd);		if (ret == -1)			return ret;	}#endif	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))		trace_sys_enter(regs, regs->orig_ax);	do_audit_syscall_entry(regs, arch);	return ret ?: regs->orig_ax;}

static int kern_do_signal(struct pt_regs *regs){	struct k_sigaction ka_copy;	siginfo_t info;	sigset_t *oldset;	int sig, handled_sig = 0;	if (test_thread_flag(TIF_RESTORE_SIGMASK))		oldset = &current->saved_sigmask;	else		oldset = &current->blocked;	while((sig = get_signal_to_deliver(&info, &ka_copy, regs, NULL)) > 0){		handled_sig = 1;		/* Whee!  Actually deliver the signal.  */		if(!handle_signal(regs, sig, &ka_copy, &info, oldset)){			/* a signal was successfully delivered; the saved			 * sigmask will have been stored in the signal frame,			 * and will be restored by sigreturn, so we can simply			 * clear the TIF_RESTORE_SIGMASK flag */			if (test_thread_flag(TIF_RESTORE_SIGMASK))				clear_thread_flag(TIF_RESTORE_SIGMASK);			break;		}	}	/* Did we come from a system call? */	if(!handled_sig && (PT_REGS_SYSCALL_NR(regs) >= 0)){		/* Restart the system call - no handlers present */		switch(PT_REGS_SYSCALL_RET(regs)){		case -ERESTARTNOHAND:		case -ERESTARTSYS:		case -ERESTARTNOINTR:			PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs);			PT_REGS_RESTART_SYSCALL(regs);			break;		case -ERESTART_RESTARTBLOCK:			PT_REGS_ORIG_SYSCALL(regs) = __NR_restart_syscall;			PT_REGS_RESTART_SYSCALL(regs);			break; 		}	}	/* This closes a way to execute a system call on the host.  If	 * you set a breakpoint on a system call instruction and singlestep	 * from it, the tracing thread used to PTRACE_SINGLESTEP the process	 * rather than PTRACE_SYSCALL it, allowing the system call to execute	 * on the host.  The tracing thread will check this flag and	 * PTRACE_SYSCALL if necessary.	 */	if(current->ptrace & PT_DTRACE)		current->thread.singlestep_syscall =			is_syscall(PT_REGS_IP(&current->thread.regs));	/* if there's no signal to deliver, we just put the saved sigmask	 * back */	if (!handled_sig && test_thread_flag(TIF_RESTORE_SIGMASK)) {		clear_thread_flag(TIF_RESTORE_SIGMASK);		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);	}	return handled_sig;}

static int do_signal_pending(sigset_t *oldset, struct pt_regs *regs){	siginfo_t info;	int signr;	struct k_sigaction ka;	int ret;	int is32 = is_32bit_task();	if (current_thread_info()->local_flags & _TLF_RESTORE_SIGMASK)		oldset = &current->saved_sigmask;	else if (!oldset)		oldset = &current->blocked;	signr = get_signal_to_deliver(&info, &ka, regs, NULL);	/* Is there any syscall restart business here ? */	check_syscall_restart(regs, &ka, signr > 0);	if (signr <= 0) {		struct thread_info *ti = current_thread_info();		/* No signal to deliver -- put the saved sigmask back */		if (ti->local_flags & _TLF_RESTORE_SIGMASK) {			ti->local_flags &= ~_TLF_RESTORE_SIGMASK;			sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);		}		return 0;               /* no signals delivered */	}        /*	 * Reenable the DABR before delivering the signal to	 * user space. The DABR will have been cleared if it	 * triggered inside the kernel.	 */	if (current->thread.dabr) {		set_dabr(current->thread.dabr);#if defined(CONFIG_BOOKE)		mtspr(SPRN_DBCR0, current->thread.dbcr0);#endif	}	if (is32) {        	if (ka.sa.sa_flags & SA_SIGINFO)			ret = handle_rt_signal32(signr, &ka, &info, oldset,					regs);		else			ret = handle_signal32(signr, &ka, &info, oldset,					regs);	} else {		ret = handle_rt_signal64(signr, &ka, &info, oldset, regs);	}	if (ret) {		spin_lock_irq(&current->sighand->siglock);		sigorsets(&current->blocked, &current->blocked,			  &ka.sa.sa_mask);		if (!(ka.sa.sa_flags & SA_NODEFER))			sigaddset(&current->blocked, signr);		recalc_sigpending();		spin_unlock_irq(&current->sighand->siglock);		/*		 * A signal was successfully delivered; the saved sigmask is in		 * its frame, and we can clear the TLF_RESTORE_SIGMASK flag.		 */		current_thread_info()->local_flags &= ~_TLF_RESTORE_SIGMASK;		/*		 * Let tracing know that we've done the handler setup.		 */		tracehook_signal_handler(signr, &info, &ka, regs,					 test_thread_flag(TIF_SINGLESTEP));	}	return ret;}

unsigned longarch_get_unmapped_area(struct file *filp, unsigned long addr,		unsigned long len, unsigned long pgoff, unsigned long flags){	struct mm_struct *mm = current->mm;	struct vm_area_struct *vma;	unsigned long start_addr;	unsigned long begin, end;	if (flags & MAP_FIXED)		return addr;	find_start_end(flags, &begin, &end);	if (len > end)		return -ENOMEM;	if (addr) {		addr = PAGE_ALIGN(addr);		vma = find_vma(mm, addr);		if (end - len >= addr &&		    (!vma || addr + len <= vma->vm_start))			return addr;	}	if (((flags & MAP_32BIT) || test_thread_flag(TIF_IA32))	    && len <= mm->cached_hole_size) {		mm->cached_hole_size = 0;		mm->free_area_cache = begin;	}	addr = mm->free_area_cache;	if (addr < begin)		addr = begin;	start_addr = addr;full_search:	addr = align_addr(addr, filp, 0);	for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {		/* At this point:  (!vma || addr < vma->vm_end). */		if (end - len < addr) {			/*			 * Start a new search - just in case we missed			 * some holes.			 */			if (start_addr != begin) {				start_addr = addr = begin;				mm->cached_hole_size = 0;				goto full_search;			}			return -ENOMEM;		}		if (!vma || addr + len <= vma->vm_start) {			/*			 * Remember the place where we stopped the search:			 */			mm->free_area_cache = addr + len;			return addr;		}		if (addr + mm->cached_hole_size < vma->vm_start)			mm->cached_hole_size = vma->vm_start - addr;		addr = vma->vm_end;		addr = align_addr(addr, filp, 0);	}}

static void do_signal(struct pt_regs *regs){	struct k_sigaction ka;	sigset_t *oldset;	siginfo_t info;	int signr;	/*	 * We want the common case to go fast, which is why we may in certain	 * cases get here from kernel mode. Just return without doing anything	 * if so.	 */	if (!user_mode(regs))		return;	if (test_thread_flag(TIF_RESTORE_SIGMASK))		oldset = &current->saved_sigmask;	else		oldset = &current->blocked;	signr = get_signal_to_deliver(&info, &ka, regs, NULL);	if (signr > 0) {		/* Whee!  Actually deliver the signal.  */		if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {			/*			 * A signal was successfully delivered; the saved			 * sigmask will have been stored in the signal frame,			 * and will be restored by sigreturn, so we can simply			 * clear the TIF_RESTORE_SIGMASK flag.			 */			if (test_thread_flag(TIF_RESTORE_SIGMASK))				clear_thread_flag(TIF_RESTORE_SIGMASK);		}		return;	}	if (regs->regs[0]) {		switch (regs->regs[2]) {		case ERESTARTNOHAND:		case ERESTARTSYS:		case ERESTARTNOINTR:			regs->regs[2] = regs->regs[0];			regs->regs[7] = regs->regs[26];			regs->cp0_epc -= 4;			break;		case ERESTART_RESTARTBLOCK:			regs->regs[2] = current->thread.abi->restart;			regs->regs[7] = regs->regs[26];			regs->cp0_epc -= 4;			break;		}		regs->regs[0] = 0;	/* Don't deal with this again.  */	}	/*	 * If there's no signal to deliver, we just put the saved sigmask	 * back	 */	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {		clear_thread_flag(TIF_RESTORE_SIGMASK);		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);	}}

longia64_rt_sigreturn (struct sigscratch *scr){	extern char ia64_strace_leave_kernel, ia64_leave_kernel;	struct sigcontext __user *sc;	struct siginfo si;	sigset_t set;	long retval;	sc = &((struct sigframe __user *) (scr->pt.r12 + 16))->sc;	/*	 * When we return to the previously executing context, r8 and r10 have already	 * been setup the way we want them.  Indeed, if the signal wasn't delivered while	 * in a system call, we must not touch r8 or r10 as otherwise user-level state	 * could be corrupted.	 */	retval = (long) &ia64_leave_kernel;	if (test_thread_flag(TIF_SYSCALL_TRACE)	    || test_thread_flag(TIF_SYSCALL_AUDIT))		/*		 * strace expects to be notified after sigreturn returns even though the		 * context to which we return may not be in the middle of a syscall.		 * Thus, the return-value that strace displays for sigreturn is		 * meaningless.		 */		retval = (long) &ia64_strace_leave_kernel;	if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))		goto give_sigsegv;	if (GET_SIGSET(&set, &sc->sc_mask))		goto give_sigsegv;	sigdelsetmask(&set, ~_BLOCKABLE);	spin_lock_irq(&current->sighand->siglock);	{		current->blocked = set;		recalc_sigpending();	}	spin_unlock_irq(&current->sighand->siglock);	if (restore_sigcontext(sc, scr))		goto give_sigsegv;#if DEBUG_SIG	printk("SIG return (%s:%d): sp=%lx ip=%lx/n",	       current->comm, current->pid, scr->pt.r12, scr->pt.cr_iip);#endif	/*	 * It is more difficult to avoid calling this function than to	 * call it and ignore errors.	 */	do_sigaltstack(&sc->sc_stack, NULL, scr->pt.r12);	return retval;  give_sigsegv:	si.si_signo = SIGSEGV;	si.si_errno = 0;	si.si_code = SI_KERNEL;	si.si_pid = current->pid;	si.si_uid = current->uid;	si.si_addr = sc;	force_sig_info(SIGSEGV, &si, current);	return retval;}

static inline intsetup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,	       int signo, sigset_t *oldset, siginfo_t *info){	struct rt_signal_frame __user *sf;	int wsaved, err, sf_size;	void __user *tail;		synchronize_user_stack();	save_and_clear_fpu();		wsaved = get_thread_wsaved();	sf_size = sizeof(struct rt_signal_frame);	if (current_thread_info()->fpsaved[0] & FPRS_FEF)		sf_size += sizeof(__siginfo_fpu_t);	if (wsaved)		sf_size += sizeof(__siginfo_rwin_t);	sf = (struct rt_signal_frame __user *)		get_sigframe(ka, regs, sf_size);	if (invalid_frame_pointer (sf))		goto sigill;	tail = (sf + 1);		err = copy_to_user(&sf->regs, regs, sizeof (*regs));	if (current_thread_info()->fpsaved[0] & FPRS_FEF) {		__siginfo_fpu_t __user *fpu_save = tail;		tail += sizeof(__siginfo_fpu_t);		err |= save_fpu_state(regs, fpu_save);		err |= __put_user((u64)fpu_save, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}	if (wsaved) {		__siginfo_rwin_t __user *rwin_save = tail;		tail += sizeof(__siginfo_rwin_t);		err |= save_rwin_state(wsaved, rwin_save);		err |= __put_user((u64)rwin_save, &sf->rwin_save);		set_thread_wsaved(0);	} else {		err |= __put_user(0, &sf->rwin_save);	}			err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);	err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);	err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);	err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));	if (!wsaved) {		err |= copy_in_user((u64 __user *)sf,				    (u64 __user *)(regs->u_regs[UREG_FP] +						   STACK_BIAS),				    sizeof(struct reg_window));	} else {		struct reg_window *rp;		rp = &current_thread_info()->reg_window[wsaved - 1];		err |= copy_to_user(sf, rp, sizeof(struct reg_window));	}	if (info)		err |= copy_siginfo_to_user(&sf->info, info);	else {		err |= __put_user(signo, &sf->info.si_signo);		err |= __put_user(SI_NOINFO, &sf->info.si_code);	}	if (err)		goto sigsegv;			regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;	regs->u_regs[UREG_I0] = signo;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;		regs->tpc = (unsigned long) ka->sa.sa_handler;	regs->tnpc = (regs->tpc + 4);	if (test_thread_flag(TIF_32BIT)) {		regs->tpc &= 0xffffffff;		regs->tnpc &= 0xffffffff;	}		regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;	return 0;sigill:	do_exit(SIGILL);	return -EINVAL;sigsegv:	force_sigsegv(signo, current);	return -EFAULT;//.........这里部分代码省略.........

static void do_signal(struct pt_regs *regs, unsigned long orig_i0){	struct k_sigaction ka;	int restart_syscall;	sigset_t *oldset;	siginfo_t info;	int signr;		if (pt_regs_is_syscall(regs) &&	    (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY)))		regs->u_regs[UREG_G6] = orig_i0;	if (current_thread_info()->status & TS_RESTORE_SIGMASK)		oldset = &current->saved_sigmask;	else		oldset = &current->blocked;#ifdef CONFIG_COMPAT	if (test_thread_flag(TIF_32BIT)) {		extern void do_signal32(sigset_t *, struct pt_regs *);		do_signal32(oldset, regs);		return;	}#endif		signr = get_signal_to_deliver(&info, &ka, regs, NULL);	restart_syscall = 0;	if (pt_regs_is_syscall(regs) &&	    (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {		restart_syscall = 1;		orig_i0 = regs->u_regs[UREG_G6];	}	if (signr > 0) {		if (restart_syscall)			syscall_restart(orig_i0, regs, &ka.sa);		if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {			current_thread_info()->status &= ~TS_RESTORE_SIGMASK;		}		return;	}	if (restart_syscall &&	    (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||	     regs->u_regs[UREG_I0] == ERESTARTSYS ||	     regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {				regs->u_regs[UREG_I0] = orig_i0;		regs->tpc -= 4;		regs->tnpc -= 4;		pt_regs_clear_syscall(regs);	}	if (restart_syscall &&	    regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {		regs->u_regs[UREG_G1] = __NR_restart_syscall;		regs->tpc -= 4;		regs->tnpc -= 4;		pt_regs_clear_syscall(regs);	}	if (current_thread_info()->status & TS_RESTORE_SIGMASK) {		current_thread_info()->status &= ~TS_RESTORE_SIGMASK;		set_current_blocked(&current->saved_sigmask);	}}

void do_rt_sigreturn(struct pt_regs *regs){	struct rt_signal_frame __user *sf;	unsigned long tpc, tnpc, tstate;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	sigset_t set;	int err;		current_thread_info()->restart_block.fn = do_no_restart_syscall;	synchronize_user_stack ();	sf = (struct rt_signal_frame __user *)		(regs->u_regs [UREG_FP] + STACK_BIAS);		if (((unsigned long) sf) & 3)		goto segv;	err = get_user(tpc, &sf->regs.tpc);	err |= __get_user(tnpc, &sf->regs.tnpc);	if (test_thread_flag(TIF_32BIT)) {		tpc &= 0xffffffff;		tnpc &= 0xffffffff;	}	err |= ((tpc | tnpc) & 3);		err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(tstate, &sf->regs.tstate);	err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));		regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));	err |= __get_user(fpu_save, &sf->fpu_save);	if (!err && fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));	err |= do_sigaltstack(&sf->stack, NULL, (unsigned long)sf);	if (err)		goto segv;	err |= __get_user(rwin_save, &sf->rwin_save);	if (!err && rwin_save) {		if (restore_rwin_state(rwin_save))			goto segv;	}	regs->tpc = tpc;	regs->tnpc = tnpc;		pt_regs_clear_syscall(regs);	sigdelsetmask(&set, ~_BLOCKABLE);	set_current_blocked(&set);	return;segv:	force_sig(SIGSEGV, current);}

static inthandle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,	      sigset_t *oldset, struct pt_regs *regs){	int ret;	/* Are we from a system call? */	if (syscall_get_nr(current, regs) >= 0) {		/* If so, check system call restarting.. */		switch (syscall_get_error(current, regs)) {		case -ERESTART_RESTARTBLOCK:		case -ERESTARTNOHAND:			regs->ax = -EINTR;			break;		case -ERESTARTSYS:			if (!(ka->sa.sa_flags & SA_RESTART)) {				regs->ax = -EINTR;				break;			}		/* fallthrough */		case -ERESTARTNOINTR:			regs->ax = regs->orig_ax;			regs->ip -= 2;			break;		}	}	/*	 * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF	 * flag so that register information in the sigcontext is correct.	 */	if (unlikely(regs->flags & X86_EFLAGS_TF) &&	    likely(test_and_clear_thread_flag(TIF_FORCED_TF)))		regs->flags &= ~X86_EFLAGS_TF;	ret = setup_rt_frame(sig, ka, info, oldset, regs);	if (ret)		return ret;#ifdef CONFIG_X86_64	/*	 * This has nothing to do with segment registers,	 * despite the name.  This magic affects uaccess.h	 * macros' behavior.  Reset it to the normal setting.	 */	set_fs(USER_DS);#endif	/*	 * Clear the direction flag as per the ABI for function entry.	 */	regs->flags &= ~X86_EFLAGS_DF;	/*	 * Clear TF when entering the signal handler, but	 * notify any tracer that was single-stepping it.	 * The tracer may want to single-step inside the	 * handler too.	 */	regs->flags &= ~X86_EFLAGS_TF;	spin_lock_irq(&current->sighand->siglock);	sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);	if (!(ka->sa.sa_flags & SA_NODEFER))		sigaddset(&current->blocked, sig);	recalc_sigpending();	spin_unlock_irq(&current->sighand->siglock);	tracehook_signal_handler(sig, info, ka, regs,				 test_thread_flag(TIF_SINGLESTEP));	return 0;}

/* Note that 'init' is a special process: it doesn't get signals it doesn't * want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. */static void do_signal(struct pt_regs *regs, unsigned long orig_i0){	struct k_sigaction ka;	int restart_syscall;	sigset_t *oldset;	siginfo_t info;	int signr;	if (pt_regs_is_syscall(regs) && (regs->psr & PSR_C))		restart_syscall = 1;	else		restart_syscall = 0;	if (test_thread_flag(TIF_RESTORE_SIGMASK))		oldset = &current->saved_sigmask;	else		oldset = &current->blocked;	signr = get_signal_to_deliver(&info, &ka, regs, NULL);	/* If the debugger messes with the program counter, it clears	 * the software "in syscall" bit, directing us to not perform	 * a syscall restart.	 */	if (restart_syscall && !pt_regs_is_syscall(regs))		restart_syscall = 0;	if (signr > 0) {		if (restart_syscall)			syscall_restart(orig_i0, regs, &ka.sa);		if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {			/* a signal was successfully delivered; the saved			 * sigmask will have been stored in the signal frame,			 * and will be restored by sigreturn, so we can simply			 * clear the TIF_RESTORE_SIGMASK flag.			 */			if (test_thread_flag(TIF_RESTORE_SIGMASK))				clear_thread_flag(TIF_RESTORE_SIGMASK);		}		return;	}	if (restart_syscall &&	    (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||	     regs->u_regs[UREG_I0] == ERESTARTSYS ||	     regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {		/* replay the system call when we are done */		regs->u_regs[UREG_I0] = orig_i0;		regs->pc -= 4;		regs->npc -= 4;		pt_regs_clear_syscall(regs);	}	if (restart_syscall &&	    regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {		regs->u_regs[UREG_G1] = __NR_restart_syscall;		regs->pc -= 4;		regs->npc -= 4;		pt_regs_clear_syscall(regs);	}	/* if there's no signal to deliver, we just put the saved sigmask	 * back	 */	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {		clear_thread_flag(TIF_RESTORE_SIGMASK);		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);	}}

asmlinkage void sparc64_get_context(struct pt_regs *regs){	struct ucontext __user *ucp = (struct ucontext __user *)		regs->u_regs[UREG_I0];	enum ctx_state prev_state = exception_enter();	mc_gregset_t __user *grp;	mcontext_t __user *mcp;	unsigned long fp, i7;	unsigned char fenab;	int err;	synchronize_user_stack();	if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp)))		goto do_sigsegv;#if 1	fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */#else	fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF);#endif			mcp = &ucp->uc_mcontext;	grp = &mcp->mc_gregs;	/* Skip over the trap instruction, first. */	if (test_thread_flag(TIF_32BIT)) {		regs->tpc   = (regs->tnpc & 0xffffffff);		regs->tnpc  = (regs->tnpc + 4) & 0xffffffff;	} else {		regs->tpc   = regs->tnpc;		regs->tnpc += 4;	}	err = 0;	if (_NSIG_WORDS == 1)		err |= __put_user(current->blocked.sig[0],				  (unsigned long __user *)&ucp->uc_sigmask);	else		err |= __copy_to_user(&ucp->uc_sigmask, &current->blocked,				      sizeof(sigset_t));	err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));	err |= __put_user(regs->tpc, &((*grp)[MC_PC]));	err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));	err |= __put_user(regs->y, &((*grp)[MC_Y]));	err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));	err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));	err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));	err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));	err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));	err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));	err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7]));	err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));	err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));	err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));	err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));	err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));	err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));	err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));	err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));	err |= __get_user(fp,		 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));	err |= __get_user(i7,		 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));	err |= __put_user(fp, &(mcp->mc_fp));	err |= __put_user(i7, &(mcp->mc_i7));	err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));	if (fenab) {		unsigned long *fpregs = current_thread_info()->fpregs;		unsigned long fprs;				fprs = current_thread_info()->fpsaved[0];		if (fprs & FPRS_DL)			err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,					    (sizeof(unsigned int) * 32));		if (fprs & FPRS_DU)			err |= copy_to_user(                          ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,			  (sizeof(unsigned int) * 32));		err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));		err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));		err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));	}	if (err)		goto do_sigsegv;out:	exception_exit(prev_state);	return;do_sigsegv:	force_sig(SIGSEGV, current);	goto out;}

void do_rt_sigreturn(struct pt_regs *regs){	unsigned long tpc, tnpc, tstate, ufp;	struct rt_signal_frame __user *sf;	__siginfo_fpu_t __user *fpu_save;	__siginfo_rwin_t __user *rwin_save;	sigset_t set;	int err;	/* Always make any pending restarted system calls return -EINTR */	current->restart_block.fn = do_no_restart_syscall;	synchronize_user_stack ();	sf = (struct rt_signal_frame __user *)		(regs->u_regs [UREG_FP] + STACK_BIAS);	/* 1. Make sure we are not getting garbage from the user */	if (invalid_frame_pointer(sf))		goto segv;	if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))		goto segv;	if ((ufp + STACK_BIAS) & 0x7)		goto segv;	err = __get_user(tpc, &sf->regs.tpc);	err |= __get_user(tnpc, &sf->regs.tnpc);	if (test_thread_flag(TIF_32BIT)) {		tpc &= 0xffffffff;		tnpc &= 0xffffffff;	}	err |= ((tpc | tnpc) & 3);	/* 2. Restore the state */	err |= __get_user(regs->y, &sf->regs.y);	err |= __get_user(tstate, &sf->regs.tstate);	err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));	/* User can only change condition codes and %asi in %tstate. */	regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));	err |= __get_user(fpu_save, &sf->fpu_save);	if (!err && fpu_save)		err |= restore_fpu_state(regs, fpu_save);	err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));	err |= restore_altstack(&sf->stack);	if (err)		goto segv;	err |= __get_user(rwin_save, &sf->rwin_save);	if (!err && rwin_save) {		if (restore_rwin_state(rwin_save))			goto segv;	}	regs->tpc = tpc;	regs->tnpc = tnpc;	/* Prevent syscall restart.  */	pt_regs_clear_syscall(regs);	set_current_blocked(&set);	return;segv:	force_sig(SIGSEGV, current);}

/* * Note that 'init' is a special process: it doesn't get signals it doesn't * want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. * * Note that we go through the signals twice: once to check the signals that * the kernel can handle, and then we build all the user-level signal handling * stack-frames in one go after that. * * "r0" and "r19" are the registers we need to restore for system call * restart. "r0" is also used as an indicator whether we can restart at * all (if we get here from anything but a syscall return, it will be 0) */static voiddo_signal(struct pt_regs * regs, struct switch_stack * sw,	  unsigned long r0, unsigned long r19){	siginfo_t info;	int signr;	unsigned long single_stepping = ptrace_cancel_bpt(current);	struct k_sigaction ka;	sigset_t *oldset;	if (test_thread_flag(TIF_RESTORE_SIGMASK))		oldset = &current->saved_sigmask;	else		oldset = &current->blocked;	/* This lets the debugger run, ... */	signr = get_signal_to_deliver(&info, &ka, regs, NULL);	/* ... so re-check the single stepping. */	single_stepping |= ptrace_cancel_bpt(current);	if (signr > 0) {		/* Whee!  Actually deliver the signal.  */		if (r0)			syscall_restart(r0, r19, regs, &ka);		if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {			/* A signal was successfully delivered, and the			   saved sigmask was stored on the signal frame,			   and will be restored by sigreturn.  So we can			   simply clear the restore sigmask flag.  */			if (test_thread_flag(TIF_RESTORE_SIGMASK))				clear_thread_flag(TIF_RESTORE_SIGMASK);		}		if (single_stepping) 			ptrace_set_bpt(current); /* re-set bpt */		return;	}	if (r0) {	  	switch (regs->r0) {		case ERESTARTNOHAND:		case ERESTARTSYS:		case ERESTARTNOINTR:			/* Reset v0 and a3 and replay syscall.  */			regs->r0 = r0;			regs->r19 = r19;			regs->pc -= 4;			break;		case ERESTART_RESTARTBLOCK:			/* Force v0 to the restart syscall and reply.  */			regs->r0 = __NR_restart_syscall;			regs->pc -= 4;			break;		}	}	/* If there's no signal to deliver, we just restore the saved mask.  */	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {		clear_thread_flag(TIF_RESTORE_SIGMASK);		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);	}	if (single_stepping)		ptrace_set_bpt(current);	/* re-set breakpoint */}

static inline intsetup_rt_frame(struct ksignal *ksig, struct pt_regs *regs){	struct rt_signal_frame __user *sf;	int wsaved, err, sf_size;	void __user *tail;	/* 1. Make sure everything is clean */	synchronize_user_stack();	save_and_clear_fpu();		wsaved = get_thread_wsaved();	sf_size = sizeof(struct rt_signal_frame);	if (current_thread_info()->fpsaved[0] & FPRS_FEF)		sf_size += sizeof(__siginfo_fpu_t);	if (wsaved)		sf_size += sizeof(__siginfo_rwin_t);	sf = (struct rt_signal_frame __user *)		get_sigframe(ksig, regs, sf_size);	if (invalid_frame_pointer (sf)) {		do_exit(SIGILL);	/* won't return, actually */		return -EINVAL;	}	tail = (sf + 1);	/* 2. Save the current process state */	err = copy_to_user(&sf->regs, regs, sizeof (*regs));	if (current_thread_info()->fpsaved[0] & FPRS_FEF) {		__siginfo_fpu_t __user *fpu_save = tail;		tail += sizeof(__siginfo_fpu_t);		err |= save_fpu_state(regs, fpu_save);		err |= __put_user((u64)fpu_save, &sf->fpu_save);	} else {		err |= __put_user(0, &sf->fpu_save);	}	if (wsaved) {		__siginfo_rwin_t __user *rwin_save = tail;		tail += sizeof(__siginfo_rwin_t);		err |= save_rwin_state(wsaved, rwin_save);		err |= __put_user((u64)rwin_save, &sf->rwin_save);		set_thread_wsaved(0);	} else {		err |= __put_user(0, &sf->rwin_save);	}		/* Setup sigaltstack */	err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]);	err |= copy_to_user(&sf->mask, sigmask_to_save(), sizeof(sigset_t));	if (!wsaved) {		err |= copy_in_user((u64 __user *)sf,				    (u64 __user *)(regs->u_regs[UREG_FP] +						   STACK_BIAS),				    sizeof(struct reg_window));	} else {		struct reg_window *rp;		rp = &current_thread_info()->reg_window[wsaved - 1];		err |= copy_to_user(sf, rp, sizeof(struct reg_window));	}	if (ksig->ka.sa.sa_flags & SA_SIGINFO)		err |= copy_siginfo_to_user(&sf->info, &ksig->info);	else {		err |= __put_user(ksig->sig, &sf->info.si_signo);		err |= __put_user(SI_NOINFO, &sf->info.si_code);	}	if (err)		return err;		/* 3. signal handler back-trampoline and parameters */	regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;	regs->u_regs[UREG_I0] = ksig->sig;	regs->u_regs[UREG_I1] = (unsigned long) &sf->info;	/* The sigcontext is passed in this way because of how it	 * is defined in GLIBC's /usr/include/bits/sigcontext.h	 * for sparc64.  It includes the 128 bytes of siginfo_t.	 */	regs->u_regs[UREG_I2] = (unsigned long) &sf->info;	/* 5. signal handler */	regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;	regs->tnpc = (regs->tpc + 4);	if (test_thread_flag(TIF_32BIT)) {		regs->tpc &= 0xffffffff;		regs->tnpc &= 0xffffffff;	}	/* 4. return to kernel instructions */	regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;	return 0;}

unsigned longarch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,			  const unsigned long len, const unsigned long pgoff,			  const unsigned long flags){	struct vm_area_struct *vma;	struct mm_struct *mm = current->mm;	unsigned long addr = addr0;	/* requested length too big for entire address space */	if (len > TASK_SIZE)		return -ENOMEM;	if (flags & MAP_FIXED)		return addr;	/* for MAP_32BIT mappings we force the legact mmap base */	if (!test_thread_flag(TIF_IA32) && (flags & MAP_32BIT))		goto bottomup;	/* requesting a specific address */	if (addr) {		addr = PAGE_ALIGN(addr);		vma = find_vma(mm, addr);		if (TASK_SIZE - len >= addr &&				(!vma || addr + len <= vma->vm_start))			return addr;	}	/* check if free_area_cache is useful for us */	if (len <= mm->cached_hole_size) {		mm->cached_hole_size = 0;		mm->free_area_cache = mm->mmap_base;	}	/* either no address requested or can't fit in requested address hole */	addr = mm->free_area_cache;	/* make sure it can fit in the remaining address space */	if (addr > len) {		unsigned long tmp_addr = align_addr(addr - len, filp,						    ALIGN_TOPDOWN);		vma = find_vma(mm, tmp_addr);		if (!vma || tmp_addr + len <= vma->vm_start)			/* remember the address as a hint for next time */			return mm->free_area_cache = tmp_addr;	}	if (mm->mmap_base < len)		goto bottomup;	addr = mm->mmap_base-len;	do {		addr = align_addr(addr, filp, ALIGN_TOPDOWN);		/*		 * Lookup failure means no vma is above this address,		 * else if new region fits below vma->vm_start,		 * return with success:		 */		vma = find_vma(mm, addr);		if (!vma || addr+len <= vma->vm_start)			/* remember the address as a hint for next time */			return mm->free_area_cache = addr;		/* remember the largest hole we saw so far */		if (addr + mm->cached_hole_size < vma->vm_start)			mm->cached_hole_size = vma->vm_start - addr;		/* try just below the current vma->vm_start */		addr = vma->vm_start-len;	} while (len < vma->vm_start);bottomup:	/*	 * A failed mmap() very likely causes application failure,	 * so fall back to the bottom-up function here. This scenario	 * can happen with large stack limits and large mmap()	 * allocations.	 */	mm->cached_hole_size = ~0UL;	mm->free_area_cache = TASK_UNMAPPED_BASE;	addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);	/*	 * Restore the topdown base:	 */	mm->free_area_cache = mm->mmap_base;	mm->cached_hole_size = ~0UL;	return addr;}

/* {set, get}context() needed for 64-bit SparcLinux userland. */asmlinkage void sparc64_set_context(struct pt_regs *regs){	struct ucontext __user *ucp = (struct ucontext __user *)		regs->u_regs[UREG_I0];	enum ctx_state prev_state = exception_enter();	mc_gregset_t __user *grp;	unsigned long pc, npc, tstate;	unsigned long fp, i7;	unsigned char fenab;	int err;	synchronize_user_stack();	if (get_thread_wsaved()					||	    (((unsigned long)ucp) & (sizeof(unsigned long)-1))	||	    (!__access_ok(ucp, sizeof(*ucp))))		goto do_sigsegv;	grp  = &ucp->uc_mcontext.mc_gregs;	err  = __get_user(pc, &((*grp)[MC_PC]));	err |= __get_user(npc, &((*grp)[MC_NPC]));	if (err || ((pc | npc) & 3))		goto do_sigsegv;	if (regs->u_regs[UREG_I1]) {		sigset_t set;		if (_NSIG_WORDS == 1) {			if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))				goto do_sigsegv;		} else {			if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))				goto do_sigsegv;		}		set_current_blocked(&set);	}	if (test_thread_flag(TIF_32BIT)) {		pc &= 0xffffffff;		npc &= 0xffffffff;	}	regs->tpc = pc;	regs->tnpc = npc;	err |= __get_user(regs->y, &((*grp)[MC_Y]));	err |= __get_user(tstate, &((*grp)[MC_TSTATE]));	regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);	regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));	err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));	err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));	err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));	err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));	err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));	err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));	/* Skip %g7 as that's the thread register in userspace.  */	err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));	err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));	err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));	err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));	err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));	err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));	err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));	err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));	err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));	err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));	err |= __put_user(fp,	      (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));	err |= __put_user(i7,	      (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));	err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));	if (fenab) {		unsigned long *fpregs = current_thread_info()->fpregs;		unsigned long fprs;				fprs_write(0);		err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));		if (fprs & FPRS_DL)			err |= copy_from_user(fpregs,					      &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),					      (sizeof(unsigned int) * 32));		if (fprs & FPRS_DU)			err |= copy_from_user(fpregs+16,			 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,			 (sizeof(unsigned int) * 32));		err |= __get_user(current_thread_info()->xfsr[0],				  &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));		err |= __get_user(current_thread_info()->gsr[0],				  &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));		regs->tstate &= ~TSTATE_PEF;	}	if (err)		goto do_sigsegv;out:	exception_exit(prev_state);	return;do_sigsegv:	force_sig(SIGSEGV, current);	goto out;}

static unsigned longhugetlb_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,				  const unsigned long len,				  const unsigned long pgoff,				  const unsigned long flags){	struct vm_area_struct *vma;	struct mm_struct *mm = current->mm;	unsigned long addr = addr0;	/* This should only ever run for 32-bit processes.  */	BUG_ON(!test_thread_flag(TIF_32BIT));	/* check if free_area_cache is useful for us */	if (len <= mm->cached_hole_size) { 	        mm->cached_hole_size = 0; 		mm->free_area_cache = mm->mmap_base; 	}	/* either no address requested or can't fit in requested address hole */	addr = mm->free_area_cache & HPAGE_MASK;	/* make sure it can fit in the remaining address space */	if (likely(addr > len)) {		vma = find_vma(mm, addr-len);		if (!vma || addr <= vma->vm_start) {			/* remember the address as a hint for next time */			return (mm->free_area_cache = addr-len);		}	}	if (unlikely(mm->mmap_base < len))		goto bottomup;	addr = (mm->mmap_base-len) & HPAGE_MASK;	do {		/*		 * Lookup failure means no vma is above this address,		 * else if new region fits below vma->vm_start,		 * return with success:		 */		vma = find_vma(mm, addr);		if (likely(!vma || addr+len <= vma->vm_start)) {			/* remember the address as a hint for next time */			return (mm->free_area_cache = addr);		} 		/* remember the largest hole we saw so far */ 		if (addr + mm->cached_hole_size < vma->vm_start) 		        mm->cached_hole_size = vma->vm_start - addr;		/* try just below the current vma->vm_start */		addr = (vma->vm_start-len) & HPAGE_MASK;	} while (likely(len < vma->vm_start));bottomup:	/*	 * A failed mmap() very likely causes application failure,	 * so fall back to the bottom-up function here. This scenario	 * can happen with large stack limits and large mmap()	 * allocations.	 */	mm->cached_hole_size = ~0UL;  	mm->free_area_cache = TASK_UNMAPPED_BASE;	addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);	/*	 * Restore the topdown base:	 */	mm->free_area_cache = mm->mmap_base;	mm->cached_hole_size = ~0UL;	return addr;}

/* Note that 'init' is a special process: it doesn't get signals it doesn't * want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. */static void do_signal(struct pt_regs *regs, unsigned long orig_i0){	struct ksignal ksig;	int restart_syscall;	bool has_handler;		/* It's a lot of work and synchronization to add a new ptrace	 * register for GDB to save and restore in order to get	 * orig_i0 correct for syscall restarts when debugging.	 *	 * Although it should be the case that most of the global	 * registers are volatile across a system call, glibc already	 * depends upon that fact that we preserve them.  So we can't	 * just use any global register to save away the orig_i0 value.	 *	 * In particular %g2, %g3, %g4, and %g5 are all assumed to be	 * preserved across a system call trap by various pieces of	 * code in glibc.	 *	 * %g7 is used as the "thread register".   %g6 is not used in	 * any fixed manner.  %g6 is used as a scratch register and	 * a compiler temporary, but it's value is never used across	 * a system call.  Therefore %g6 is usable for orig_i0 storage.	 */	if (pt_regs_is_syscall(regs) &&	    (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY)))		regs->u_regs[UREG_G6] = orig_i0;#ifdef CONFIG_COMPAT	if (test_thread_flag(TIF_32BIT)) {		do_signal32(regs);		return;	}#endif		has_handler = get_signal(&ksig);	restart_syscall = 0;	if (pt_regs_is_syscall(regs) &&	    (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {		restart_syscall = 1;		orig_i0 = regs->u_regs[UREG_G6];	}	if (has_handler) {		if (restart_syscall)			syscall_restart(orig_i0, regs, &ksig.ka.sa);		signal_setup_done(setup_rt_frame(&ksig, regs), &ksig, 0);	} else {		if (restart_syscall) {			switch (regs->u_regs[UREG_I0]) {			case ERESTARTNOHAND:	     		case ERESTARTSYS:			case ERESTARTNOINTR:				/* replay the system call when we are done */				regs->u_regs[UREG_I0] = orig_i0;				regs->tpc -= 4;				regs->tnpc -= 4;				pt_regs_clear_syscall(regs);			case ERESTART_RESTARTBLOCK:				regs->u_regs[UREG_G1] = __NR_restart_syscall;				regs->tpc -= 4;				regs->tnpc -= 4;				pt_regs_clear_syscall(regs);			}		}		restore_saved_sigmask();	}}

unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags){	struct mm_struct *mm = current->mm;	struct vm_area_struct * vma;	unsigned long task_size = TASK_SIZE;	unsigned long start_addr;	int do_color_align;	if (flags & MAP_FIXED) {		/* We do not accept a shared mapping if it would violate		 * cache aliasing constraints.		 */		if ((flags & MAP_SHARED) &&		    ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))			return -EINVAL;		return addr;	}	if (test_thread_flag(TIF_32BIT))		task_size = STACK_TOP32;	if (unlikely(len > task_size || len >= VA_EXCLUDE_START))		return -ENOMEM;	do_color_align = 0;	if (filp || (flags & MAP_SHARED))		do_color_align = 1;	if (addr) {		if (do_color_align)			addr = COLOUR_ALIGN(addr, pgoff);		else			addr = PAGE_ALIGN(addr);		vma = find_vma(mm, addr);		if (task_size - len >= addr &&		    (!vma || addr + len <= vma->vm_start))			return addr;	}	if (len > mm->cached_hole_size) {	        start_addr = addr = mm->free_area_cache;	} else {	        start_addr = addr = TASK_UNMAPPED_BASE;	        mm->cached_hole_size = 0;	}	task_size -= len;full_search:	if (do_color_align)		addr = COLOUR_ALIGN(addr, pgoff);	else		addr = PAGE_ALIGN(addr);	for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {		/* At this point:  (!vma || addr < vma->vm_end). */		if (addr < VA_EXCLUDE_START &&		    (addr + len) >= VA_EXCLUDE_START) {			addr = VA_EXCLUDE_END;			vma = find_vma(mm, VA_EXCLUDE_END);		}		if (unlikely(task_size < addr)) {			if (start_addr != TASK_UNMAPPED_BASE) {				start_addr = addr = TASK_UNMAPPED_BASE;				mm->cached_hole_size = 0;				goto full_search;			}			return -ENOMEM;		}		if (likely(!vma || addr + len <= vma->vm_start)) {			/*			 * Remember the place where we stopped the search:			 */			mm->free_area_cache = addr + len;			return addr;		}		if (addr + mm->cached_hole_size < vma->vm_start)		        mm->cached_hole_size = vma->vm_start - addr;		addr = vma->vm_end;		if (do_color_align)			addr = COLOUR_ALIGN(addr, pgoff);	}}

static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,			  sigset_t *set){	struct rt_sigframe __user *frame;	int rsig;	set_fs(USER_DS);	frame = get_sigframe(ka, sizeof(*frame));	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))		goto give_sigsegv;	rsig = sig;	if (sig < 32 &&	    __current_thread_info->exec_domain &&	    __current_thread_info->exec_domain->signal_invmap)		rsig = __current_thread_info->exec_domain->signal_invmap[sig];	if (__put_user(rsig,		&frame->sig) ||	    __put_user(&frame->info,	&frame->pinfo) ||	    __put_user(&frame->uc,	&frame->puc))		goto give_sigsegv;	if (copy_siginfo_to_user(&frame->info, info))		goto give_sigsegv;	/* Create the ucontext.  */	if (__put_user(0, &frame->uc.uc_flags) ||	    __put_user(NULL, &frame->uc.uc_link) ||	    __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp) ||	    __put_user(sas_ss_flags(__frame->sp), &frame->uc.uc_stack.ss_flags) ||	    __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size))		goto give_sigsegv;	if (setup_sigcontext(&frame->uc.uc_mcontext, set->sig[0]))		goto give_sigsegv;	if (__copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)))		goto give_sigsegv;	/* Set up to return from userspace.  If provided, use a stub	 * already in userspace.  */	if (ka->sa.sa_flags & SA_RESTORER) {		if (__put_user(ka->sa.sa_restorer, &frame->pretcode))			goto give_sigsegv;	}	else {		/* Set up the following code on the stack:		 *	setlos	#__NR_sigreturn,gr7		 *	tira	gr0,0		 */		if (__put_user((__sigrestore_t)frame->retcode, &frame->pretcode) ||		    __put_user(0x8efc0000|__NR_rt_sigreturn, &frame->retcode[0]) ||		    __put_user(0xc0700000, &frame->retcode[1]))			goto give_sigsegv;		flush_icache_range((unsigned long) frame->retcode,				   (unsigned long) (frame->retcode + 2));	}	/* Set up registers for signal handler */	if (current->personality & FDPIC_FUNCPTRS) {		struct fdpic_func_descriptor __user *funcptr =			(struct fdpic_func_descriptor __user *) ka->sa.sa_handler;		struct fdpic_func_descriptor desc;		if (copy_from_user(&desc, funcptr, sizeof(desc)))			goto give_sigsegv;		__frame->pc = desc.text;		__frame->gr15 = desc.GOT;	} else {		__frame->pc   = (unsigned long) ka->sa.sa_handler;		__frame->gr15 = 0;	}	__frame->sp  = (unsigned long) frame;	__frame->lr  = (unsigned long) &frame->retcode;	__frame->gr8 = sig;	__frame->gr9 = (unsigned long) &frame->info;	/* the tracer may want to single-step inside the handler */	if (test_thread_flag(TIF_SINGLESTEP))		ptrace_notify(SIGTRAP);#if DEBUG_SIG	printk("SIG deliver %d (%s:%d): sp=%p pc=%lx ra=%p/n",	       sig, current->comm, current->pid, frame, __frame->pc,	       frame->pretcode);#endif	return 0;give_sigsegv:	force_sigsegv(sig, current);	return -EFAULT;} /* end setup_rt_frame() */

int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from){	int err = 0;	bool ia32 = test_thread_flag(TIF_IA32);	if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))		return -EFAULT;	put_user_try {		/* If you change siginfo_t structure, please make sure that		   this code is fixed accordingly.		   It should never copy any pad contained in the structure		   to avoid security leaks, but must copy the generic		   3 ints plus the relevant union member.  */		put_user_ex(from->si_signo, &to->si_signo);		put_user_ex(from->si_errno, &to->si_errno);		put_user_ex((short)from->si_code, &to->si_code);		if (from->si_code < 0) {			put_user_ex(from->si_pid, &to->si_pid);			put_user_ex(from->si_uid, &to->si_uid);			put_user_ex(ptr_to_compat(from->si_ptr), &to->si_ptr);		} else {			/*			 * First 32bits of unions are always present:			 * si_pid === si_band === si_tid === si_addr(LS half)			 */			put_user_ex(from->_sifields._pad[0],					  &to->_sifields._pad[0]);			switch (from->si_code >> 16) {			case __SI_FAULT >> 16:				break;			case __SI_SYS >> 16:				put_user_ex(from->si_syscall, &to->si_syscall);				put_user_ex(from->si_arch, &to->si_arch);				break;			case __SI_CHLD >> 16:				if (ia32) {					put_user_ex(from->si_utime, &to->si_utime);					put_user_ex(from->si_stime, &to->si_stime);				} else {					put_user_ex(from->si_utime, &to->_sifields._sigchld_x32._utime);					put_user_ex(from->si_stime, &to->_sifields._sigchld_x32._stime);				}				put_user_ex(from->si_status, &to->si_status);				/* FALL THROUGH */			default:			case __SI_KILL >> 16:				put_user_ex(from->si_uid, &to->si_uid);				break;			case __SI_POLL >> 16:				put_user_ex(from->si_fd, &to->si_fd);				break;			case __SI_TIMER >> 16:				put_user_ex(from->si_overrun, &to->si_overrun);				put_user_ex(ptr_to_compat(from->si_ptr),					    &to->si_ptr);				break;				 /* This is not generated by the kernel as of now.  */			case __SI_RT >> 16:			case __SI_MESGQ >> 16:				put_user_ex(from->si_uid, &to->si_uid);				put_user_ex(from->si_int, &to->si_int);				break;			}		}	} put_user_catch(err);	return err;}

/* * Note that 'init' is a special process: it doesn't get signals it doesn't * want to handle. Thus you cannot kill init even with a SIGKILL even by * mistake. */static void do_signal(void){	struct k_sigaction ka;	siginfo_t info;	sigset_t *oldset;	int signr;	/*	 * We want the common case to go fast, which	 * is why we may in certain cases get here from	 * kernel mode. Just return without doing anything	 * if so.	 */	if (!user_mode(__frame))		return;	if (try_to_freeze())		goto no_signal;	if (test_thread_flag(TIF_RESTORE_SIGMASK))		oldset = &current->saved_sigmask;	else		oldset = &current->blocked;	signr = get_signal_to_deliver(&info, &ka, __frame, NULL);	if (signr > 0) {		if (handle_signal(signr, &info, &ka, oldset) == 0) {			/* a signal was successfully delivered; the saved			 * sigmask will have been stored in the signal frame,			 * and will be restored by sigreturn, so we can simply			 * clear the TIF_RESTORE_SIGMASK flag */			if (test_thread_flag(TIF_RESTORE_SIGMASK))				clear_thread_flag(TIF_RESTORE_SIGMASK);			tracehook_signal_handler(signr, &info, &ka, __frame,						 test_thread_flag(TIF_SINGLESTEP));		}		return;	}no_signal:	/* Did we come from a system call? */	if (__frame->syscallno != -1) {		/* Restart the system call - no handlers present */		switch (__frame->gr8) {		case -ERESTARTNOHAND:		case -ERESTARTSYS:		case -ERESTARTNOINTR:			__frame->gr8 = __frame->orig_gr8;			__frame->pc -= 4;			break;		case -ERESTART_RESTARTBLOCK:			__frame->gr7 = __NR_restart_syscall;			__frame->pc -= 4;			break;		}		__frame->syscallno = -1;	}	/* if there's no signal to deliver, we just put the saved sigmask	 * back */	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {		clear_thread_flag(TIF_RESTORE_SIGMASK);		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);	}} /* end do_signal() */

long arch_ptrace(struct task_struct *child, long request,		 unsigned long addr, unsigned long data){	int ret;	void __user *addrp = (void __user *) addr;	void __user *datavp = (void __user *) data;	unsigned long __user *datalp = (void __user *) data;	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:		ret = generic_ptrace_peekdata(child, addr, data);		break;	/* Read the word at location addr in the USER area. */	case PTRACE_PEEKUSR: {		struct pt_regs *regs;		union fpureg *fregs;		unsigned long tmp = 0;		regs = task_pt_regs(child);		ret = 0;  /* Default return value. */		switch (addr) {		case 0 ... 31:			tmp = regs->regs[addr];			break;		case FPR_BASE ... FPR_BASE + 31:			if (!tsk_used_math(child)) {				/* FP not yet used */				tmp = -1;				break;			}			fregs = get_fpu_regs(child);#ifdef CONFIG_32BIT			if (test_thread_flag(TIF_32BIT_FPREGS)) {				/*				 * The odd registers are actually the high				 * order bits of the values stored in the even				 * registers - unless we're using r2k_switch.S.				 */				tmp = get_fpr32(&fregs[(addr & ~1) - FPR_BASE],						addr & 1);				break;			}#endif			tmp = get_fpr32(&fregs[addr - FPR_BASE], 0);			break;		case PC:			tmp = regs->cp0_epc;			break;		case CAUSE:			tmp = regs->cp0_cause;			break;		case BADVADDR:			tmp = regs->cp0_badvaddr;			break;		case MMHI:			tmp = regs->hi;			break;		case MMLO:			tmp = regs->lo;			break;#ifdef CONFIG_CPU_HAS_SMARTMIPS		case ACX:			tmp = regs->acx;			break;#endif		case FPC_CSR:			tmp = child->thread.fpu.fcr31;			break;		case FPC_EIR:			/* implementation / version register */			tmp = boot_cpu_data.fpu_id;			break;		case DSP_BASE ... DSP_BASE + 5: {			dspreg_t *dregs;			if (!cpu_has_dsp) {				tmp = 0;				ret = -EIO;				goto out;			}			dregs = __get_dsp_regs(child);			tmp = (unsigned long) (dregs[addr - DSP_BASE]);			break;		}		case DSP_CONTROL:			if (!cpu_has_dsp) {				tmp = 0;				ret = -EIO;				goto out;			}			tmp = child->thread.dsp.dspcontrol;			break;		default:			tmp = 0;			ret = -EIO;//.........这里部分代码省略.........

/* * Debug exception handlers. */static int breakpoint_handler(unsigned long unused, unsigned int esr,			      struct pt_regs *regs){	int i, step = 0, *kernel_step;	u32 ctrl_reg;	u64 addr, val;	struct perf_event *bp, **slots;	struct debug_info *debug_info;	struct arch_hw_breakpoint_ctrl ctrl;	slots = this_cpu_ptr(bp_on_reg);	addr = instruction_pointer(regs);	debug_info = &current->thread.debug;	for (i = 0; i < core_num_brps; ++i) {		rcu_read_lock();		bp = slots[i];		if (bp == NULL)			goto unlock;		/* Check if the breakpoint value matches. */		val = read_wb_reg(AARCH64_DBG_REG_BVR, i);		if (val != (addr & ~0x3))			goto unlock;		/* Possible match, check the byte address select to confirm. */		ctrl_reg = read_wb_reg(AARCH64_DBG_REG_BCR, i);		decode_ctrl_reg(ctrl_reg, &ctrl);		if (!((1 << (addr & 0x3)) & ctrl.len))			goto unlock;		counter_arch_bp(bp)->trigger = addr;		perf_bp_event(bp, regs);		/* Do we need to handle the stepping? */		if (!bp->overflow_handler)			step = 1;unlock:		rcu_read_unlock();	}	if (!step)		return 0;	if (user_mode(regs)) {		debug_info->bps_disabled = 1;		toggle_bp_registers(AARCH64_DBG_REG_BCR, DBG_ACTIVE_EL0, 0);		/* If we're already stepping a watchpoint, just return. */		if (debug_info->wps_disabled)			return 0;		if (test_thread_flag(TIF_SINGLESTEP))			debug_info->suspended_step = 1;		else			user_enable_single_step(current);	} else {		toggle_bp_registers(AARCH64_DBG_REG_BCR, DBG_ACTIVE_EL1, 0);		kernel_step = this_cpu_ptr(&stepping_kernel_bp);		if (*kernel_step != ARM_KERNEL_STEP_NONE)			return 0;		if (kernel_active_single_step()) {			*kernel_step = ARM_KERNEL_STEP_SUSPEND;		} else {			*kernel_step = ARM_KERNEL_STEP_ACTIVE;			kernel_enable_single_step(regs);		}	}	return 0;}