Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 9026843952adac5b123c7b8dc961e5c15828d9e1

Authored by Al Viro 2012-12-15 03:47:53 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

generic compat_sys_sigaltstack()

Again, conditional on CONFIG_GENERIC_SIGALTSTACK

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 10 changed files with 67 additions and 67 deletions Inline Diff

arch/x86/ia32/ia32_signal.c
arch/x86/ia32/ia32entry.S
arch/x86/include/asm/ia32.h
arch/x86/include/asm/sys_ia32.h
arch/x86/kernel/entry_64.S
arch/x86/kernel/signal.c
arch/x86/syscalls/syscall_32.tbl
arch/x86/syscalls/syscall_64.tbl
include/linux/compat.h
kernel/signal.c

arch/x86/ia32/ia32_signal.c

Diff comments View file @ 9026843

 /*
  *  linux/arch/x86_64/ia32/ia32_signal.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
  *  2000-12-*   x86-64 compatibility mode signal handling by Andi Kleen
  */
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/wait.h>
 #include <linux/unistd.h>
 #include <linux/stddef.h>
 #include <linux/personality.h>
 #include <linux/compat.h>
 #include <linux/binfmts.h>
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/i387.h>
 #include <asm/fpu-internal.h>
 #include <asm/ptrace.h>
 #include <asm/ia32_unistd.h>
 #include <asm/user32.h>
 #include <asm/sigcontext32.h>
 #include <asm/proto.h>
 #include <asm/vdso.h>
 #include <asm/sigframe.h>
 #include <asm/sighandling.h>
 #include <asm/sys_ia32.h>
 #include <asm/smap.h>
 #define FIX_EFLAGS	__FIX_EFLAGS
 int copy_siginfo_to_user32(compat_siginfo_t __user *to, 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;
 }
 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 {
 	int err = 0;
 	u32 ptr32;
 	if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
 		return -EFAULT;
 	get_user_try {
 		get_user_ex(to->si_signo, &from->si_signo);
 		get_user_ex(to->si_errno, &from->si_errno);
 		get_user_ex(to->si_code, &from->si_code);
 		get_user_ex(to->si_pid, &from->si_pid);
 		get_user_ex(to->si_uid, &from->si_uid);
 		get_user_ex(ptr32, &from->si_ptr);
 		to->si_ptr = compat_ptr(ptr32);
 	} get_user_catch(err);
 	return err;
 }
 asmlinkage long sys32_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
 	sigset_t blocked;
 	siginitset(&blocked, mask);
 	return sigsuspend(&blocked);
 }
-asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
-				  stack_ia32_t __user *uoss_ptr,
-				  struct pt_regs *regs)
-{
-	stack_t uss, uoss;
-	int ret, err = 0;
-	mm_segment_t seg;
-	if (uss_ptr) {
-		u32 ptr;
-		memset(&uss, 0, sizeof(stack_t));
-		if (!access_ok(VERIFY_READ, uss_ptr, sizeof(stack_ia32_t)))
-			return -EFAULT;
-		get_user_try {
-			get_user_ex(ptr, &uss_ptr->ss_sp);
-			get_user_ex(uss.ss_flags, &uss_ptr->ss_flags);
-			get_user_ex(uss.ss_size, &uss_ptr->ss_size);
-		} get_user_catch(err);
-		if (err)
-			return -EFAULT;
-		uss.ss_sp = compat_ptr(ptr);
-	}
-	seg = get_fs();
-	set_fs(KERNEL_DS);
-	ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
-			     (stack_t __force __user *) &uoss, regs->sp);
-	set_fs(seg);
-	if (ret >= 0 && uoss_ptr)  {
-		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(stack_ia32_t)))
-			return -EFAULT;
-		put_user_try {
-			put_user_ex(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp);
-			put_user_ex(uoss.ss_flags, &uoss_ptr->ss_flags);
-			put_user_ex(uoss.ss_size, &uoss_ptr->ss_size);
-		} put_user_catch(err);
-		if (err)
-			ret = -EFAULT;
-	}
-	return ret;
-}
 /*
  * Do a signal return; undo the signal stack.
  */
 #define loadsegment_gs(v)	load_gs_index(v)
 #define loadsegment_fs(v)	loadsegment(fs, v)
 #define loadsegment_ds(v)	loadsegment(ds, v)
 #define loadsegment_es(v)	loadsegment(es, v)
 #define get_user_seg(seg)	({ unsigned int v; savesegment(seg, v); v; })
 #define set_user_seg(seg, v)	loadsegment_##seg(v)
 #define COPY(x)			{		\
 	get_user_ex(regs->x, &sc->x);		\
 }
 #define GET_SEG(seg)		({			\
 	unsigned short tmp;				\
 	get_user_ex(tmp, &sc->seg);			\
 	tmp;						\
 })
 #define COPY_SEG_CPL3(seg)	do {			\
 	regs->seg = GET_SEG(seg) | 3;			\
 } while (0)
 #define RELOAD_SEG(seg)		{		\
 	unsigned int pre = GET_SEG(seg);	\
 	unsigned int cur = get_user_seg(seg);	\
 	pre |= 3;				\
 	if (pre != cur)				\
 		set_user_seg(seg, pre);		\
 }
 static int ia32_restore_sigcontext(struct pt_regs *regs,
 				   struct sigcontext_ia32 __user *sc,
 				   unsigned int *pax)
 {
 	unsigned int tmpflags, err = 0;
 	void __user *buf;
 	u32 tmp;
 	/* Always make any pending restarted system calls return -EINTR */
 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 	get_user_try {
 		/*
 		 * Reload fs and gs if they have changed in the signal
 		 * handler.  This does not handle long fs/gs base changes in
 		 * the handler, but does not clobber them at least in the
 		 * normal case.
 		 */
 		RELOAD_SEG(gs);
 		RELOAD_SEG(fs);
 		RELOAD_SEG(ds);
 		RELOAD_SEG(es);
 		COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 		COPY(dx); COPY(cx); COPY(ip);
 		/* Don't touch extended registers */
 		COPY_SEG_CPL3(cs);
 		COPY_SEG_CPL3(ss);
 		get_user_ex(tmpflags, &sc->flags);
 		regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 		/* disable syscall checks */
 		regs->orig_ax = -1;
 		get_user_ex(tmp, &sc->fpstate);
 		buf = compat_ptr(tmp);
 		get_user_ex(*pax, &sc->ax);
 	} get_user_catch(err);
 	err |= restore_xstate_sig(buf, 1);
 	return err;
 }
 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 {
 	struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
 	sigset_t set;
 	unsigned int ax;
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__get_user(set.sig[0], &frame->sc.oldmask)
 	    || (_COMPAT_NSIG_WORDS > 1
 		&& __copy_from_user((((char *) &set.sig) + 4),
 				    &frame->extramask,
 				    sizeof(frame->extramask))))
 		goto badframe;
 	set_current_blocked(&set);
 	if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
 		goto badframe;
 	return ax;
 badframe:
 	signal_fault(regs, frame, "32bit sigreturn");
 	return 0;
 }
 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 {
 	struct rt_sigframe_ia32 __user *frame;
 	sigset_t set;
 	unsigned int ax;
-	struct pt_regs tregs;
 	frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 		goto badframe;
 	set_current_blocked(&set);
 	if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 		goto badframe;
-	tregs = *regs;
+	if (compat_restore_altstack(&frame->uc.uc_stack))
-	if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 		goto badframe;
 	return ax;
 badframe:
 	signal_fault(regs, frame, "32bit rt sigreturn");
 	return 0;
 }
 /*
  * Set up a signal frame.
  */
 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
 				 void __user *fpstate,
 				 struct pt_regs *regs, unsigned int mask)
 {
 	int err = 0;
 	put_user_try {
 		put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
 		put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
 		put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
 		put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
 		put_user_ex(regs->di, &sc->di);
 		put_user_ex(regs->si, &sc->si);
 		put_user_ex(regs->bp, &sc->bp);
 		put_user_ex(regs->sp, &sc->sp);
 		put_user_ex(regs->bx, &sc->bx);
 		put_user_ex(regs->dx, &sc->dx);
 		put_user_ex(regs->cx, &sc->cx);
 		put_user_ex(regs->ax, &sc->ax);
 		put_user_ex(current->thread.trap_nr, &sc->trapno);
 		put_user_ex(current->thread.error_code, &sc->err);
 		put_user_ex(regs->ip, &sc->ip);
 		put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
 		put_user_ex(regs->flags, &sc->flags);
 		put_user_ex(regs->sp, &sc->sp_at_signal);
 		put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
 		put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);
 		/* non-iBCS2 extensions.. */
 		put_user_ex(mask, &sc->oldmask);
 		put_user_ex(current->thread.cr2, &sc->cr2);
 	} put_user_catch(err);
 	return err;
 }
 /*
  * Determine which stack to use..
  */
 static void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
 				 size_t frame_size,
 				 void __user **fpstate)
 {
 	unsigned long sp;
 	/* Default to using normal stack */
 	sp = regs->sp;
 	/* This is the X/Open sanctioned signal stack switching.  */
 	if (ka->sa.sa_flags & SA_ONSTACK) {
 		if (sas_ss_flags(sp) == 0)
 			sp = current->sas_ss_sp + current->sas_ss_size;
 	}
 	/* This is the legacy signal stack switching. */
 	else if ((regs->ss & 0xffff) != __USER32_DS &&
 		!(ka->sa.sa_flags & SA_RESTORER) &&
 		 ka->sa.sa_restorer)
 		sp = (unsigned long) ka->sa.sa_restorer;
 	if (used_math()) {
 		unsigned long fx_aligned, math_size;
 		sp = alloc_mathframe(sp, 1, &fx_aligned, &math_size);
 		*fpstate = (struct _fpstate_ia32 __user *) sp;
 		if (save_xstate_sig(*fpstate, (void __user *)fx_aligned,
 				    math_size) < 0)
 			return (void __user *) -1L;
 	}
 	sp -= frame_size;
 	/* Align the stack pointer according to the i386 ABI,
 	 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 	sp = ((sp + 4) & -16ul) - 4;
 	return (void __user *) sp;
 }
 int ia32_setup_frame(int sig, struct k_sigaction *ka,
 		     compat_sigset_t *set, struct pt_regs *regs)
 {
 	struct sigframe_ia32 __user *frame;
 	void __user *restorer;
 	int err = 0;
 	void __user *fpstate = NULL;
 	/* copy_to_user optimizes that into a single 8 byte store */
 	static const struct {
 		u16 poplmovl;
 		u32 val;
 		u16 int80;
 	} __attribute__((packed)) code = {
 		0xb858,		 /* popl %eax ; movl $...,%eax */
 		__NR_ia32_sigreturn,
 		0x80cd,		/* int $0x80 */
 	};
 	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		return -EFAULT;
 	if (__put_user(sig, &frame->sig))
 		return -EFAULT;
 	if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 		return -EFAULT;
 	if (_COMPAT_NSIG_WORDS > 1) {
 		if (__copy_to_user(frame->extramask, &set->sig[1],
 				   sizeof(frame->extramask)))
 			return -EFAULT;
 	}
 	if (ka->sa.sa_flags & SA_RESTORER) {
 		restorer = ka->sa.sa_restorer;
 	} else {
 		/* Return stub is in 32bit vsyscall page */
 		if (current->mm->context.vdso)
 			restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 						 sigreturn);
 		else
 			restorer = &frame->retcode;
 	}
 	put_user_try {
 		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 		/*
 		 * These are actually not used anymore, but left because some
 		 * gdb versions depend on them as a marker.
 		 */
 		put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 	} put_user_catch(err);
 	if (err)
 		return -EFAULT;
 	/* Set up registers for signal handler */
 	regs->sp = (unsigned long) frame;
 	regs->ip = (unsigned long) ka->sa.sa_handler;
 	/* Make -mregparm=3 work */
 	regs->ax = sig;
 	regs->dx = 0;
 	regs->cx = 0;
 	loadsegment(ds, __USER32_DS);
 	loadsegment(es, __USER32_DS);
 	regs->cs = __USER32_CS;
 	regs->ss = __USER32_DS;
 	return 0;
 }
 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 			compat_sigset_t *set, struct pt_regs *regs)
 {
 	struct rt_sigframe_ia32 __user *frame;
 	void __user *restorer;
 	int err = 0;
 	void __user *fpstate = NULL;
 	/* __copy_to_user optimizes that into a single 8 byte store */
 	static const struct {
 		u8 movl;
 		u32 val;
 		u16 int80;
 		u8  pad;
 	} __attribute__((packed)) code = {
 		0xb8,
 		__NR_ia32_rt_sigreturn,
 		0x80cd,
 		0,
 	};
 	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		return -EFAULT;
 	put_user_try {
 		put_user_ex(sig, &frame->sig);
 		put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
 		put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
 		/* Create the ucontext.  */
 		if (cpu_has_xsave)
 			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 		else
 			put_user_ex(0, &frame->uc.uc_flags);
 		put_user_ex(0, &frame->uc.uc_link);
 		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 		put_user_ex(sas_ss_flags(regs->sp),
 			    &frame->uc.uc_stack.ss_flags);
 		put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 		if (ka->sa.sa_flags & SA_RESTORER)
 			restorer = ka->sa.sa_restorer;
 		else
 			restorer = VDSO32_SYMBOL(current->mm->context.vdso,
 						 rt_sigreturn);
 		put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
 		/*
 		 * Not actually used anymore, but left because some gdb
 		 * versions need it.
 		 */
 		put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
 	} put_user_catch(err);
 	err |= copy_siginfo_to_user32(&frame->info, info);
 	err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 				     regs, set->sig[0]);
 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 	if (err)
 		return -EFAULT;
 	/* Set up registers for signal handler */
 	regs->sp = (unsigned long) frame;
 	regs->ip = (unsigned long) ka->sa.sa_handler;
 	/* Make -mregparm=3 work */
 	regs->ax = sig;
 	regs->dx = (unsigned long) &frame->info;
 	regs->cx = (unsigned long) &frame->uc;
 	loadsegment(ds, __USER32_DS);
 	loadsegment(es, __USER32_DS);
 	regs->cs = __USER32_CS;
 	regs->ss = __USER32_DS;
 	return 0;
 }

arch/x86/ia32/ia32entry.S

Diff comments View file @ 9026843

 /*
  * Compatibility mode system call entry point for x86-64.
  *
  * Copyright 2000-2002 Andi Kleen, SuSE Labs.
  */
 #include <asm/dwarf2.h>
 #include <asm/calling.h>
 #include <asm/asm-offsets.h>
 #include <asm/current.h>
 #include <asm/errno.h>
 #include <asm/ia32_unistd.h>
 #include <asm/thread_info.h>
 #include <asm/segment.h>
 #include <asm/irqflags.h>
 #include <asm/asm.h>
 #include <asm/smap.h>
 #include <linux/linkage.h>
 #include <linux/err.h>
 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
 #include <linux/elf-em.h>
 #define AUDIT_ARCH_I386		(EM_386|__AUDIT_ARCH_LE)
 #define __AUDIT_ARCH_LE	   0x40000000
 #ifndef CONFIG_AUDITSYSCALL
 #define sysexit_audit ia32_ret_from_sys_call
 #define sysretl_audit ia32_ret_from_sys_call
 #endif
 	.section .entry.text, "ax"
 	.macro IA32_ARG_FIXUP noebp=0
 	movl	%edi,%r8d
 	.if \noebp
 	.else
 	movl	%ebp,%r9d
 	.endif
 	xchg	%ecx,%esi
 	movl	%ebx,%edi
 	movl	%edx,%edx	/* zero extension */
 	.endm
 	/* clobbers %eax */
 	.macro  CLEAR_RREGS offset=0, _r9=rax
 	xorl 	%eax,%eax
 	movq	%rax,\offset+R11(%rsp)
 	movq	%rax,\offset+R10(%rsp)
 	movq	%\_r9,\offset+R9(%rsp)
 	movq	%rax,\offset+R8(%rsp)
 	.endm
 	/*
 	 * Reload arg registers from stack in case ptrace changed them.
 	 * We don't reload %eax because syscall_trace_enter() returned
 	 * the %rax value we should see.  Instead, we just truncate that
 	 * value to 32 bits again as we did on entry from user mode.
 	 * If it's a new value set by user_regset during entry tracing,
 	 * this matches the normal truncation of the user-mode value.
 	 * If it's -1 to make us punt the syscall, then (u32)-1 is still
 	 * an appropriately invalid value.
 	 */
 	.macro LOAD_ARGS32 offset, _r9=0
 	.if \_r9
 	movl \offset+16(%rsp),%r9d
 	.endif
 	movl \offset+40(%rsp),%ecx
 	movl \offset+48(%rsp),%edx
 	movl \offset+56(%rsp),%esi
 	movl \offset+64(%rsp),%edi
 	movl %eax,%eax			/* zero extension */
 	.endm
 	.macro CFI_STARTPROC32 simple
 	CFI_STARTPROC	\simple
 	CFI_UNDEFINED	r8
 	CFI_UNDEFINED	r9
 	CFI_UNDEFINED	r10
 	CFI_UNDEFINED	r11
 	CFI_UNDEFINED	r12
 	CFI_UNDEFINED	r13
 	CFI_UNDEFINED	r14
 	CFI_UNDEFINED	r15
 	.endm
 #ifdef CONFIG_PARAVIRT
 ENTRY(native_usergs_sysret32)
 	swapgs
 	sysretl
 ENDPROC(native_usergs_sysret32)
 ENTRY(native_irq_enable_sysexit)
 	swapgs
 	sti
 	sysexit
 ENDPROC(native_irq_enable_sysexit)
 #endif
 /*
  * 32bit SYSENTER instruction entry.
  *
  * Arguments:
  * %eax	System call number.
  * %ebx Arg1
  * %ecx Arg2
  * %edx Arg3
  * %esi Arg4
  * %edi Arg5
  * %ebp user stack
  * 0(%ebp) Arg6
  *
  * Interrupts off.
  *
  * This is purely a fast path. For anything complicated we use the int 0x80
  * path below.	Set up a complete hardware stack frame to share code
  * with the int 0x80 path.
  */
 ENTRY(ia32_sysenter_target)
 	CFI_STARTPROC32	simple
 	CFI_SIGNAL_FRAME
 	CFI_DEF_CFA	rsp,0
 	CFI_REGISTER	rsp,rbp
 	SWAPGS_UNSAFE_STACK
 	movq	PER_CPU_VAR(kernel_stack), %rsp
 	addq	$(KERNEL_STACK_OFFSET),%rsp
 	/*
 	 * No need to follow this irqs on/off section: the syscall
 	 * disabled irqs, here we enable it straight after entry:
 	 */
 	ENABLE_INTERRUPTS(CLBR_NONE)
  	movl	%ebp,%ebp		/* zero extension */
 	pushq_cfi $__USER32_DS
 	/*CFI_REL_OFFSET ss,0*/
 	pushq_cfi %rbp
 	CFI_REL_OFFSET rsp,0
 	pushfq_cfi
 	/*CFI_REL_OFFSET rflags,0*/
 	movl	TI_sysenter_return+THREAD_INFO(%rsp,3*8-KERNEL_STACK_OFFSET),%r10d
 	CFI_REGISTER rip,r10
 	pushq_cfi $__USER32_CS
 	/*CFI_REL_OFFSET cs,0*/
 	movl	%eax, %eax
 	pushq_cfi %r10
 	CFI_REL_OFFSET rip,0
 	pushq_cfi %rax
 	cld
 	SAVE_ARGS 0,1,0
  	/* no need to do an access_ok check here because rbp has been
  	   32bit zero extended */
 	ASM_STAC
 1:	movl	(%rbp),%ebp
 	_ASM_EXTABLE(1b,ia32_badarg)
 	ASM_CLAC
 	orl     $TS_COMPAT,TI_status+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	testl   $_TIF_WORK_SYSCALL_ENTRY,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	CFI_REMEMBER_STATE
 	jnz  sysenter_tracesys
 	cmpq	$(IA32_NR_syscalls-1),%rax
 	ja	ia32_badsys
 sysenter_do_call:
 	IA32_ARG_FIXUP
 sysenter_dispatch:
 	call	*ia32_sys_call_table(,%rax,8)
 	movq	%rax,RAX-ARGOFFSET(%rsp)
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	testl	$_TIF_ALLWORK_MASK,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jnz	sysexit_audit
 sysexit_from_sys_call:
 	andl    $~TS_COMPAT,TI_status+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	/* clear IF, that popfq doesn't enable interrupts early */
 	andl  $~0x200,EFLAGS-R11(%rsp)
 	movl	RIP-R11(%rsp),%edx		/* User %eip */
 	CFI_REGISTER rip,rdx
 	RESTORE_ARGS 0,24,0,0,0,0
 	xorq	%r8,%r8
 	xorq	%r9,%r9
 	xorq	%r10,%r10
 	xorq	%r11,%r11
 	popfq_cfi
 	/*CFI_RESTORE rflags*/
 	popq_cfi %rcx				/* User %esp */
 	CFI_REGISTER rsp,rcx
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS_SYSEXIT32
 #ifdef CONFIG_AUDITSYSCALL
 	.macro auditsys_entry_common
 	movl %esi,%r9d			/* 6th arg: 4th syscall arg */
 	movl %edx,%r8d			/* 5th arg: 3rd syscall arg */
 	/* (already in %ecx)		   4th arg: 2nd syscall arg */
 	movl %ebx,%edx			/* 3rd arg: 1st syscall arg */
 	movl %eax,%esi			/* 2nd arg: syscall number */
 	movl $AUDIT_ARCH_I386,%edi	/* 1st arg: audit arch */
 	call __audit_syscall_entry
 	movl RAX-ARGOFFSET(%rsp),%eax	/* reload syscall number */
 	cmpq $(IA32_NR_syscalls-1),%rax
 	ja ia32_badsys
 	movl %ebx,%edi			/* reload 1st syscall arg */
 	movl RCX-ARGOFFSET(%rsp),%esi	/* reload 2nd syscall arg */
 	movl RDX-ARGOFFSET(%rsp),%edx	/* reload 3rd syscall arg */
 	movl RSI-ARGOFFSET(%rsp),%ecx	/* reload 4th syscall arg */
 	movl RDI-ARGOFFSET(%rsp),%r8d	/* reload 5th syscall arg */
 	.endm
 	.macro auditsys_exit exit
 	testl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT),TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jnz ia32_ret_from_sys_call
 	TRACE_IRQS_ON
 	sti
 	movl %eax,%esi		/* second arg, syscall return value */
 	cmpl $-MAX_ERRNO,%eax	/* is it an error ? */
 	jbe 1f
 	movslq %eax, %rsi	/* if error sign extend to 64 bits */
 1:	setbe %al		/* 1 if error, 0 if not */
 	movzbl %al,%edi		/* zero-extend that into %edi */
 	call __audit_syscall_exit
 	movq RAX-ARGOFFSET(%rsp),%rax	/* reload syscall return value */
 	movl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT),%edi
 	cli
 	TRACE_IRQS_OFF
 	testl %edi,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jz \exit
 	CLEAR_RREGS -ARGOFFSET
 	jmp int_with_check
 	.endm
 sysenter_auditsys:
 	CFI_RESTORE_STATE
 	auditsys_entry_common
 	movl %ebp,%r9d			/* reload 6th syscall arg */
 	jmp sysenter_dispatch
 sysexit_audit:
 	auditsys_exit sysexit_from_sys_call
 #endif
 sysenter_tracesys:
 #ifdef CONFIG_AUDITSYSCALL
 	testl	$(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jz	sysenter_auditsys
 #endif
 	SAVE_REST
 	CLEAR_RREGS
 	movq	$-ENOSYS,RAX(%rsp)/* ptrace can change this for a bad syscall */
 	movq	%rsp,%rdi        /* &pt_regs -> arg1 */
 	call	syscall_trace_enter
 	LOAD_ARGS32 ARGOFFSET  /* reload args from stack in case ptrace changed it */
 	RESTORE_REST
 	cmpq	$(IA32_NR_syscalls-1),%rax
 	ja	int_ret_from_sys_call /* sysenter_tracesys has set RAX(%rsp) */
 	jmp	sysenter_do_call
 	CFI_ENDPROC
 ENDPROC(ia32_sysenter_target)
 /*
  * 32bit SYSCALL instruction entry.
  *
  * Arguments:
  * %eax	System call number.
  * %ebx Arg1
  * %ecx return EIP
  * %edx Arg3
  * %esi Arg4
  * %edi Arg5
  * %ebp Arg2    [note: not saved in the stack frame, should not be touched]
  * %esp user stack
  * 0(%esp) Arg6
  *
  * Interrupts off.
  *
  * This is purely a fast path. For anything complicated we use the int 0x80
  * path below.	Set up a complete hardware stack frame to share code
  * with the int 0x80 path.
  */
 ENTRY(ia32_cstar_target)
 	CFI_STARTPROC32	simple
 	CFI_SIGNAL_FRAME
 	CFI_DEF_CFA	rsp,KERNEL_STACK_OFFSET
 	CFI_REGISTER	rip,rcx
 	/*CFI_REGISTER	rflags,r11*/
 	SWAPGS_UNSAFE_STACK
 	movl	%esp,%r8d
 	CFI_REGISTER	rsp,r8
 	movq	PER_CPU_VAR(kernel_stack),%rsp
 	/*
 	 * No need to follow this irqs on/off section: the syscall
 	 * disabled irqs and here we enable it straight after entry:
 	 */
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	SAVE_ARGS 8,0,0
 	movl 	%eax,%eax	/* zero extension */
 	movq	%rax,ORIG_RAX-ARGOFFSET(%rsp)
 	movq	%rcx,RIP-ARGOFFSET(%rsp)
 	CFI_REL_OFFSET rip,RIP-ARGOFFSET
 	movq	%rbp,RCX-ARGOFFSET(%rsp) /* this lies slightly to ptrace */
 	movl	%ebp,%ecx
 	movq	$__USER32_CS,CS-ARGOFFSET(%rsp)
 	movq	$__USER32_DS,SS-ARGOFFSET(%rsp)
 	movq	%r11,EFLAGS-ARGOFFSET(%rsp)
 	/*CFI_REL_OFFSET rflags,EFLAGS-ARGOFFSET*/
 	movq	%r8,RSP-ARGOFFSET(%rsp)
 	CFI_REL_OFFSET rsp,RSP-ARGOFFSET
 	/* no need to do an access_ok check here because r8 has been
 	   32bit zero extended */
 	/* hardware stack frame is complete now */
 	ASM_STAC
 1:	movl	(%r8),%r9d
 	_ASM_EXTABLE(1b,ia32_badarg)
 	ASM_CLAC
 	orl     $TS_COMPAT,TI_status+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	testl   $_TIF_WORK_SYSCALL_ENTRY,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	CFI_REMEMBER_STATE
 	jnz   cstar_tracesys
 	cmpq $IA32_NR_syscalls-1,%rax
 	ja  ia32_badsys
 cstar_do_call:
 	IA32_ARG_FIXUP 1
 cstar_dispatch:
 	call *ia32_sys_call_table(,%rax,8)
 	movq %rax,RAX-ARGOFFSET(%rsp)
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	testl $_TIF_ALLWORK_MASK,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jnz sysretl_audit
 sysretl_from_sys_call:
 	andl $~TS_COMPAT,TI_status+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	RESTORE_ARGS 0,-ARG_SKIP,0,0,0
 	movl RIP-ARGOFFSET(%rsp),%ecx
 	CFI_REGISTER rip,rcx
 	movl EFLAGS-ARGOFFSET(%rsp),%r11d
 	/*CFI_REGISTER rflags,r11*/
 	xorq	%r10,%r10
 	xorq	%r9,%r9
 	xorq	%r8,%r8
 	TRACE_IRQS_ON
 	movl RSP-ARGOFFSET(%rsp),%esp
 	CFI_RESTORE rsp
 	USERGS_SYSRET32
 #ifdef CONFIG_AUDITSYSCALL
 cstar_auditsys:
 	CFI_RESTORE_STATE
 	movl %r9d,R9-ARGOFFSET(%rsp)	/* register to be clobbered by call */
 	auditsys_entry_common
 	movl R9-ARGOFFSET(%rsp),%r9d	/* reload 6th syscall arg */
 	jmp cstar_dispatch
 sysretl_audit:
 	auditsys_exit sysretl_from_sys_call
 #endif
 cstar_tracesys:
 #ifdef CONFIG_AUDITSYSCALL
 	testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jz cstar_auditsys
 #endif
 	xchgl %r9d,%ebp
 	SAVE_REST
 	CLEAR_RREGS 0, r9
 	movq $-ENOSYS,RAX(%rsp)	/* ptrace can change this for a bad syscall */
 	movq %rsp,%rdi        /* &pt_regs -> arg1 */
 	call syscall_trace_enter
 	LOAD_ARGS32 ARGOFFSET, 1  /* reload args from stack in case ptrace changed it */
 	RESTORE_REST
 	xchgl %ebp,%r9d
 	cmpq $(IA32_NR_syscalls-1),%rax
 	ja int_ret_from_sys_call /* cstar_tracesys has set RAX(%rsp) */
 	jmp cstar_do_call
 END(ia32_cstar_target)
 ia32_badarg:
 	ASM_CLAC
 	movq $-EFAULT,%rax
 	jmp ia32_sysret
 	CFI_ENDPROC
 /*
  * Emulated IA32 system calls via int 0x80.
  *
  * Arguments:
  * %eax	System call number.
  * %ebx Arg1
  * %ecx Arg2
  * %edx Arg3
  * %esi Arg4
  * %edi Arg5
  * %ebp Arg6    [note: not saved in the stack frame, should not be touched]
  *
  * Notes:
  * Uses the same stack frame as the x86-64 version.
  * All registers except %eax must be saved (but ptrace may violate that)
  * Arguments are zero extended. For system calls that want sign extension and
  * take long arguments a wrapper is needed. Most calls can just be called
  * directly.
  * Assumes it is only called from user space and entered with interrupts off.
  */
 ENTRY(ia32_syscall)
 	CFI_STARTPROC32	simple
 	CFI_SIGNAL_FRAME
 	CFI_DEF_CFA	rsp,SS+8-RIP
 	/*CFI_REL_OFFSET	ss,SS-RIP*/
 	CFI_REL_OFFSET	rsp,RSP-RIP
 	/*CFI_REL_OFFSET	rflags,EFLAGS-RIP*/
 	/*CFI_REL_OFFSET	cs,CS-RIP*/
 	CFI_REL_OFFSET	rip,RIP-RIP
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	SWAPGS
 	/*
 	 * No need to follow this irqs on/off section: the syscall
 	 * disabled irqs and here we enable it straight after entry:
 	 */
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	movl %eax,%eax
 	pushq_cfi %rax
 	cld
 	/* note the registers are not zero extended to the sf.
 	   this could be a problem. */
 	SAVE_ARGS 0,1,0
 	orl $TS_COMPAT,TI_status+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jnz ia32_tracesys
 	cmpq $(IA32_NR_syscalls-1),%rax
 	ja ia32_badsys
 ia32_do_call:
 	IA32_ARG_FIXUP
 	call *ia32_sys_call_table(,%rax,8) # xxx: rip relative
 ia32_sysret:
 	movq %rax,RAX-ARGOFFSET(%rsp)
 ia32_ret_from_sys_call:
 	CLEAR_RREGS -ARGOFFSET
 	jmp int_ret_from_sys_call
 ia32_tracesys:
 	SAVE_REST
 	CLEAR_RREGS
 	movq $-ENOSYS,RAX(%rsp)	/* ptrace can change this for a bad syscall */
 	movq %rsp,%rdi        /* &pt_regs -> arg1 */
 	call syscall_trace_enter
 	LOAD_ARGS32 ARGOFFSET  /* reload args from stack in case ptrace changed it */
 	RESTORE_REST
 	cmpq $(IA32_NR_syscalls-1),%rax
 	ja  int_ret_from_sys_call	/* ia32_tracesys has set RAX(%rsp) */
 	jmp ia32_do_call
 END(ia32_syscall)
 ia32_badsys:
 	movq $0,ORIG_RAX-ARGOFFSET(%rsp)
 	movq $-ENOSYS,%rax
 	jmp ia32_sysret
 	CFI_ENDPROC
 	.macro PTREGSCALL label, func, arg
 	ALIGN
 GLOBAL(\label)
 	leaq \func(%rip),%rax
 	leaq -ARGOFFSET+8(%rsp),\arg	/* 8 for return address */
 	jmp  ia32_ptregs_common
 	.endm
 	CFI_STARTPROC32
 	PTREGSCALL stub32_rt_sigreturn, sys32_rt_sigreturn, %rdi
 	PTREGSCALL stub32_sigreturn, sys32_sigreturn, %rdi
-	PTREGSCALL stub32_sigaltstack, sys32_sigaltstack, %rdx
 	PTREGSCALL stub32_execve, compat_sys_execve, %rcx
 	PTREGSCALL stub32_fork, sys_fork, %rdi
 	PTREGSCALL stub32_vfork, sys_vfork, %rdi
 	PTREGSCALL stub32_iopl, sys_iopl, %rsi
 	ALIGN
 GLOBAL(stub32_clone)
 	leaq sys_clone(%rip),%rax
 	mov	%r8, %rcx
 	jmp  ia32_ptregs_common
 	ALIGN
 ia32_ptregs_common:
 	popq %r11
 	CFI_ENDPROC
 	CFI_STARTPROC32	simple
 	CFI_SIGNAL_FRAME
 	CFI_DEF_CFA	rsp,SS+8-ARGOFFSET
 	CFI_REL_OFFSET	rax,RAX-ARGOFFSET
 	CFI_REL_OFFSET	rcx,RCX-ARGOFFSET
 	CFI_REL_OFFSET	rdx,RDX-ARGOFFSET
 	CFI_REL_OFFSET	rsi,RSI-ARGOFFSET
 	CFI_REL_OFFSET	rdi,RDI-ARGOFFSET
 	CFI_REL_OFFSET	rip,RIP-ARGOFFSET
 /*	CFI_REL_OFFSET	cs,CS-ARGOFFSET*/
 /*	CFI_REL_OFFSET	rflags,EFLAGS-ARGOFFSET*/
 	CFI_REL_OFFSET	rsp,RSP-ARGOFFSET
 /*	CFI_REL_OFFSET	ss,SS-ARGOFFSET*/
 	SAVE_REST
 	call *%rax
 	RESTORE_REST
 	jmp  ia32_sysret	/* misbalances the return cache */
 	CFI_ENDPROC
 END(ia32_ptregs_common)

arch/x86/include/asm/ia32.h

Diff comments View file @ 9026843

 #ifndef _ASM_X86_IA32_H
 #define _ASM_X86_IA32_H
 #ifdef CONFIG_IA32_EMULATION
 #include <linux/compat.h>
 /*
  * 32 bit structures for IA32 support.
  */
 #include <asm/sigcontext32.h>
 /* signal.h */
 struct sigaction32 {
 	unsigned int  sa_handler;	/* Really a pointer, but need to deal
 					   with 32 bits */
 	unsigned int sa_flags;
 	unsigned int sa_restorer;	/* Another 32 bit pointer */
 	compat_sigset_t sa_mask;	/* A 32 bit mask */
 };
 struct old_sigaction32 {
 	unsigned int  sa_handler;	/* Really a pointer, but need to deal
 					   with 32 bits */
 	compat_old_sigset_t sa_mask;	/* A 32 bit mask */
 	unsigned int sa_flags;
 	unsigned int sa_restorer;	/* Another 32 bit pointer */
 };
-typedef struct sigaltstack_ia32 {
-	unsigned int	ss_sp;
-	int		ss_flags;
-	unsigned int	ss_size;
-} stack_ia32_t;
 struct ucontext_ia32 {
 	unsigned int	  uc_flags;
 	unsigned int 	  uc_link;
-	stack_ia32_t	  uc_stack;
+	compat_stack_t	  uc_stack;
 	struct sigcontext_ia32 uc_mcontext;
 	compat_sigset_t	  uc_sigmask;	/* mask last for extensibility */
 };
 struct ucontext_x32 {
 	unsigned int	  uc_flags;
 	unsigned int 	  uc_link;
-	stack_ia32_t	  uc_stack;
+	compat_stack_t	  uc_stack;
 	unsigned int	  uc__pad0;     /* needed for alignment */
 	struct sigcontext uc_mcontext;  /* the 64-bit sigcontext type */
 	compat_sigset_t	  uc_sigmask;	/* mask last for extensibility */
 };
 /* This matches struct stat64 in glibc2.2, hence the absolutely
  * insane amounts of padding around dev_t's.
  */
 struct stat64 {
 	unsigned long long	st_dev;
 	unsigned char		__pad0[4];
 #define STAT64_HAS_BROKEN_ST_INO	1
 	unsigned int		__st_ino;
 	unsigned int		st_mode;
 	unsigned int		st_nlink;
 	unsigned int		st_uid;
 	unsigned int		st_gid;
 	unsigned long long	st_rdev;
 	unsigned char		__pad3[4];
 	long long		st_size;
 	unsigned int		st_blksize;
 	long long		st_blocks;/* Number 512-byte blocks allocated */
 	unsigned 		st_atime;
 	unsigned 		st_atime_nsec;
 	unsigned 		st_mtime;
 	unsigned 		st_mtime_nsec;
 	unsigned 		st_ctime;
 	unsigned 		st_ctime_nsec;
 	unsigned long long	st_ino;
 } __attribute__((packed));
 #define IA32_STACK_TOP IA32_PAGE_OFFSET
 #ifdef __KERNEL__
 struct linux_binprm;
 extern int ia32_setup_arg_pages(struct linux_binprm *bprm,
 				unsigned long stack_top, int exec_stack);
 struct mm_struct;
 extern void ia32_pick_mmap_layout(struct mm_struct *mm);
 #endif
 #endif /* !CONFIG_IA32_SUPPORT */
 #endif /* _ASM_X86_IA32_H */

arch/x86/include/asm/sys_ia32.h

Diff comments View file @ 9026843

 /*
  * sys_ia32.h - Linux ia32 syscall interfaces
  *
  * Copyright (c) 2008 Jaswinder Singh Rajput
  *
  * This file is released under the GPLv2.
  * See the file COPYING for more details.
  */
 #ifndef _ASM_X86_SYS_IA32_H
 #define _ASM_X86_SYS_IA32_H
 #ifdef CONFIG_COMPAT
 #include <linux/compiler.h>
 #include <linux/linkage.h>
 #include <linux/types.h>
 #include <linux/signal.h>
 #include <asm/compat.h>
 #include <asm/ia32.h>
 /* ia32/sys_ia32.c */
 asmlinkage long sys32_truncate64(const char __user *, unsigned long, unsigned long);
 asmlinkage long sys32_ftruncate64(unsigned int, unsigned long, unsigned long);
 asmlinkage long sys32_stat64(const char __user *, struct stat64 __user *);
 asmlinkage long sys32_lstat64(const char __user *, struct stat64 __user *);
 asmlinkage long sys32_fstat64(unsigned int, struct stat64 __user *);
 asmlinkage long sys32_fstatat(unsigned int, const char __user *,
 			      struct stat64 __user *, int);
 struct mmap_arg_struct32;
 asmlinkage long sys32_mmap(struct mmap_arg_struct32 __user *);
 asmlinkage long sys32_mprotect(unsigned long, size_t, unsigned long);
 struct sigaction32;
 struct old_sigaction32;
 asmlinkage long sys32_rt_sigaction(int, struct sigaction32 __user *,
 				   struct sigaction32 __user *, unsigned int);
 asmlinkage long sys32_sigaction(int, struct old_sigaction32 __user *,
 				struct old_sigaction32 __user *);
 asmlinkage long sys32_alarm(unsigned int);
 asmlinkage long sys32_waitpid(compat_pid_t, unsigned int __user *, int);
 asmlinkage long sys32_sysfs(int, u32, u32);
 asmlinkage long sys32_sched_rr_get_interval(compat_pid_t,
 					    struct compat_timespec __user *);
 asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *, compat_size_t);
 asmlinkage long sys32_rt_sigqueueinfo(int, int, compat_siginfo_t __user *);
 asmlinkage long sys32_pread(unsigned int, char __user *, u32, u32, u32);
 asmlinkage long sys32_pwrite(unsigned int, const char __user *, u32, u32, u32);
 asmlinkage long sys32_personality(unsigned long);
 asmlinkage long sys32_sendfile(int, int, compat_off_t __user *, s32);
 long sys32_lseek(unsigned int, int, unsigned int);
 long sys32_kill(int, int);
 long sys32_fadvise64_64(int, __u32, __u32, __u32, __u32, int);
 long sys32_vm86_warning(void);
 long sys32_lookup_dcookie(u32, u32, char __user *, size_t);
 asmlinkage ssize_t sys32_readahead(int, unsigned, unsigned, size_t);
 asmlinkage long sys32_sync_file_range(int, unsigned, unsigned,
 				      unsigned, unsigned, int);
 asmlinkage long sys32_fadvise64(int, unsigned, unsigned, size_t, int);
 asmlinkage long sys32_fallocate(int, int, unsigned,
 				unsigned, unsigned, unsigned);
 /* ia32/ia32_signal.c */
 asmlinkage long sys32_sigsuspend(int, int, old_sigset_t);
-asmlinkage long sys32_sigaltstack(const stack_ia32_t __user *,
-				  stack_ia32_t __user *, struct pt_regs *);
 asmlinkage long sys32_sigreturn(struct pt_regs *);
 asmlinkage long sys32_rt_sigreturn(struct pt_regs *);
 /* ia32/ipc32.c */
 asmlinkage long sys32_ipc(u32, int, int, int, compat_uptr_t, u32);
 asmlinkage long sys32_fanotify_mark(int, unsigned int, u32, u32, int,
 				    const char __user *);
 #endif /* CONFIG_COMPAT */
 #endif /* _ASM_X86_SYS_IA32_H */

arch/x86/kernel/entry_64.S

Diff comments View file @ 9026843

 /*
  *  linux/arch/x86_64/entry.S
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *  Copyright (C) 2000, 2001, 2002  Andi Kleen SuSE Labs
  *  Copyright (C) 2000  Pavel Machek <pavel@suse.cz>
  */
 /*
  * entry.S contains the system-call and fault low-level handling routines.
  *
  * Some of this is documented in Documentation/x86/entry_64.txt
  *
  * NOTE: This code handles signal-recognition, which happens every time
  * after an interrupt and after each system call.
  *
  * Normal syscalls and interrupts don't save a full stack frame, this is
  * only done for syscall tracing, signals or fork/exec et.al.
  *
  * A note on terminology:
  * - top of stack: Architecture defined interrupt frame from SS to RIP
  * at the top of the kernel process stack.
  * - partial stack frame: partially saved registers up to R11.
  * - full stack frame: Like partial stack frame, but all register saved.
  *
  * Some macro usage:
  * - CFI macros are used to generate dwarf2 unwind information for better
  * backtraces. They don't change any code.
  * - SAVE_ALL/RESTORE_ALL - Save/restore all registers
  * - SAVE_ARGS/RESTORE_ARGS - Save/restore registers that C functions modify.
  * There are unfortunately lots of special cases where some registers
  * not touched. The macro is a big mess that should be cleaned up.
  * - SAVE_REST/RESTORE_REST - Handle the registers not saved by SAVE_ARGS.
  * Gives a full stack frame.
  * - ENTRY/END Define functions in the symbol table.
  * - FIXUP_TOP_OF_STACK/RESTORE_TOP_OF_STACK - Fix up the hardware stack
  * frame that is otherwise undefined after a SYSCALL
  * - TRACE_IRQ_* - Trace hard interrupt state for lock debugging.
  * - errorentry/paranoidentry/zeroentry - Define exception entry points.
  */
 #include <linux/linkage.h>
 #include <asm/segment.h>
 #include <asm/cache.h>
 #include <asm/errno.h>
 #include <asm/dwarf2.h>
 #include <asm/calling.h>
 #include <asm/asm-offsets.h>
 #include <asm/msr.h>
 #include <asm/unistd.h>
 #include <asm/thread_info.h>
 #include <asm/hw_irq.h>
 #include <asm/page_types.h>
 #include <asm/irqflags.h>
 #include <asm/paravirt.h>
 #include <asm/ftrace.h>
 #include <asm/percpu.h>
 #include <asm/asm.h>
 #include <asm/rcu.h>
 #include <asm/smap.h>
 #include <linux/err.h>
 /* Avoid __ASSEMBLER__'ifying <linux/audit.h> just for this.  */
 #include <linux/elf-em.h>
 #define AUDIT_ARCH_X86_64	(EM_X86_64|__AUDIT_ARCH_64BIT|__AUDIT_ARCH_LE)
 #define __AUDIT_ARCH_64BIT 0x80000000
 #define __AUDIT_ARCH_LE	   0x40000000
 	.code64
 	.section .entry.text, "ax"
 #ifdef CONFIG_FUNCTION_TRACER
 #ifdef CC_USING_FENTRY
 # define function_hook	__fentry__
 #else
 # define function_hook	mcount
 #endif
 #ifdef CONFIG_DYNAMIC_FTRACE
 ENTRY(function_hook)
 	retq
 END(function_hook)
 /* skip is set if stack has been adjusted */
 .macro ftrace_caller_setup skip=0
 	MCOUNT_SAVE_FRAME \skip
 	/* Load the ftrace_ops into the 3rd parameter */
 	leaq function_trace_op, %rdx
 	/* Load ip into the first parameter */
 	movq RIP(%rsp), %rdi
 	subq $MCOUNT_INSN_SIZE, %rdi
 	/* Load the parent_ip into the second parameter */
 #ifdef CC_USING_FENTRY
 	movq SS+16(%rsp), %rsi
 #else
 	movq 8(%rbp), %rsi
 #endif
 .endm
 ENTRY(ftrace_caller)
 	/* Check if tracing was disabled (quick check) */
 	cmpl $0, function_trace_stop
 	jne  ftrace_stub
 	ftrace_caller_setup
 	/* regs go into 4th parameter (but make it NULL) */
 	movq $0, %rcx
 GLOBAL(ftrace_call)
 	call ftrace_stub
 	MCOUNT_RESTORE_FRAME
 ftrace_return:
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 GLOBAL(ftrace_graph_call)
 	jmp ftrace_stub
 #endif
 GLOBAL(ftrace_stub)
 	retq
 END(ftrace_caller)
 ENTRY(ftrace_regs_caller)
 	/* Save the current flags before compare (in SS location)*/
 	pushfq
 	/* Check if tracing was disabled (quick check) */
 	cmpl $0, function_trace_stop
 	jne  ftrace_restore_flags
 	/* skip=8 to skip flags saved in SS */
 	ftrace_caller_setup 8
 	/* Save the rest of pt_regs */
 	movq %r15, R15(%rsp)
 	movq %r14, R14(%rsp)
 	movq %r13, R13(%rsp)
 	movq %r12, R12(%rsp)
 	movq %r11, R11(%rsp)
 	movq %r10, R10(%rsp)
 	movq %rbp, RBP(%rsp)
 	movq %rbx, RBX(%rsp)
 	/* Copy saved flags */
 	movq SS(%rsp), %rcx
 	movq %rcx, EFLAGS(%rsp)
 	/* Kernel segments */
 	movq $__KERNEL_DS, %rcx
 	movq %rcx, SS(%rsp)
 	movq $__KERNEL_CS, %rcx
 	movq %rcx, CS(%rsp)
 	/* Stack - skipping return address */
 	leaq SS+16(%rsp), %rcx
 	movq %rcx, RSP(%rsp)
 	/* regs go into 4th parameter */
 	leaq (%rsp), %rcx
 GLOBAL(ftrace_regs_call)
 	call ftrace_stub
 	/* Copy flags back to SS, to restore them */
 	movq EFLAGS(%rsp), %rax
 	movq %rax, SS(%rsp)
 	/* Handlers can change the RIP */
 	movq RIP(%rsp), %rax
 	movq %rax, SS+8(%rsp)
 	/* restore the rest of pt_regs */
 	movq R15(%rsp), %r15
 	movq R14(%rsp), %r14
 	movq R13(%rsp), %r13
 	movq R12(%rsp), %r12
 	movq R10(%rsp), %r10
 	movq RBP(%rsp), %rbp
 	movq RBX(%rsp), %rbx
 	/* skip=8 to skip flags saved in SS */
 	MCOUNT_RESTORE_FRAME 8
 	/* Restore flags */
 	popfq
 	jmp ftrace_return
 ftrace_restore_flags:
 	popfq
 	jmp  ftrace_stub
 END(ftrace_regs_caller)
 #else /* ! CONFIG_DYNAMIC_FTRACE */
 ENTRY(function_hook)
 	cmpl $0, function_trace_stop
 	jne  ftrace_stub
 	cmpq $ftrace_stub, ftrace_trace_function
 	jnz trace
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 	cmpq $ftrace_stub, ftrace_graph_return
 	jnz ftrace_graph_caller
 	cmpq $ftrace_graph_entry_stub, ftrace_graph_entry
 	jnz ftrace_graph_caller
 #endif
 GLOBAL(ftrace_stub)
 	retq
 trace:
 	MCOUNT_SAVE_FRAME
 	movq RIP(%rsp), %rdi
 #ifdef CC_USING_FENTRY
 	movq SS+16(%rsp), %rsi
 #else
 	movq 8(%rbp), %rsi
 #endif
 	subq $MCOUNT_INSN_SIZE, %rdi
 	call   *ftrace_trace_function
 	MCOUNT_RESTORE_FRAME
 	jmp ftrace_stub
 END(function_hook)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 #endif /* CONFIG_FUNCTION_TRACER */
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 ENTRY(ftrace_graph_caller)
 	MCOUNT_SAVE_FRAME
 #ifdef CC_USING_FENTRY
 	leaq SS+16(%rsp), %rdi
 	movq $0, %rdx	/* No framepointers needed */
 #else
 	leaq 8(%rbp), %rdi
 	movq (%rbp), %rdx
 #endif
 	movq RIP(%rsp), %rsi
 	subq $MCOUNT_INSN_SIZE, %rsi
 	call	prepare_ftrace_return
 	MCOUNT_RESTORE_FRAME
 	retq
 END(ftrace_graph_caller)
 GLOBAL(return_to_handler)
 	subq  $24, %rsp
 	/* Save the return values */
 	movq %rax, (%rsp)
 	movq %rdx, 8(%rsp)
 	movq %rbp, %rdi
 	call ftrace_return_to_handler
 	movq %rax, %rdi
 	movq 8(%rsp), %rdx
 	movq (%rsp), %rax
 	addq $24, %rsp
 	jmp *%rdi
 #endif
 #ifndef CONFIG_PREEMPT
 #define retint_kernel retint_restore_args
 #endif
 #ifdef CONFIG_PARAVIRT
 ENTRY(native_usergs_sysret64)
 	swapgs
 	sysretq
 ENDPROC(native_usergs_sysret64)
 #endif /* CONFIG_PARAVIRT */
 .macro TRACE_IRQS_IRETQ offset=ARGOFFSET
 #ifdef CONFIG_TRACE_IRQFLAGS
 	bt   $9,EFLAGS-\offset(%rsp)	/* interrupts off? */
 	jnc  1f
 	TRACE_IRQS_ON
 1:
 #endif
 .endm
 /*
  * When dynamic function tracer is enabled it will add a breakpoint
  * to all locations that it is about to modify, sync CPUs, update
  * all the code, sync CPUs, then remove the breakpoints. In this time
  * if lockdep is enabled, it might jump back into the debug handler
  * outside the updating of the IST protection. (TRACE_IRQS_ON/OFF).
  *
  * We need to change the IDT table before calling TRACE_IRQS_ON/OFF to
  * make sure the stack pointer does not get reset back to the top
  * of the debug stack, and instead just reuses the current stack.
  */
 #if defined(CONFIG_DYNAMIC_FTRACE) && defined(CONFIG_TRACE_IRQFLAGS)
 .macro TRACE_IRQS_OFF_DEBUG
 	call debug_stack_set_zero
 	TRACE_IRQS_OFF
 	call debug_stack_reset
 .endm
 .macro TRACE_IRQS_ON_DEBUG
 	call debug_stack_set_zero
 	TRACE_IRQS_ON
 	call debug_stack_reset
 .endm
 .macro TRACE_IRQS_IRETQ_DEBUG offset=ARGOFFSET
 	bt   $9,EFLAGS-\offset(%rsp)	/* interrupts off? */
 	jnc  1f
 	TRACE_IRQS_ON_DEBUG
 1:
 .endm
 #else
 # define TRACE_IRQS_OFF_DEBUG		TRACE_IRQS_OFF
 # define TRACE_IRQS_ON_DEBUG		TRACE_IRQS_ON
 # define TRACE_IRQS_IRETQ_DEBUG		TRACE_IRQS_IRETQ
 #endif
 /*
  * C code is not supposed to know about undefined top of stack. Every time
  * a C function with an pt_regs argument is called from the SYSCALL based
  * fast path FIXUP_TOP_OF_STACK is needed.
  * RESTORE_TOP_OF_STACK syncs the syscall state after any possible ptregs
  * manipulation.
  */
 	/* %rsp:at FRAMEEND */
 	.macro FIXUP_TOP_OF_STACK tmp offset=0
 	movq PER_CPU_VAR(old_rsp),\tmp
 	movq \tmp,RSP+\offset(%rsp)
 	movq $__USER_DS,SS+\offset(%rsp)
 	movq $__USER_CS,CS+\offset(%rsp)
 	movq $-1,RCX+\offset(%rsp)
 	movq R11+\offset(%rsp),\tmp  /* get eflags */
 	movq \tmp,EFLAGS+\offset(%rsp)
 	.endm
 	.macro RESTORE_TOP_OF_STACK tmp offset=0
 	movq RSP+\offset(%rsp),\tmp
 	movq \tmp,PER_CPU_VAR(old_rsp)
 	movq EFLAGS+\offset(%rsp),\tmp
 	movq \tmp,R11+\offset(%rsp)
 	.endm
 	.macro FAKE_STACK_FRAME child_rip
 	/* push in order ss, rsp, eflags, cs, rip */
 	xorl %eax, %eax
 	pushq_cfi $__KERNEL_DS /* ss */
 	/*CFI_REL_OFFSET	ss,0*/
 	pushq_cfi %rax /* rsp */
 	CFI_REL_OFFSET	rsp,0
 	pushq_cfi $(X86_EFLAGS_IF|X86_EFLAGS_BIT1) /* eflags - interrupts on */
 	/*CFI_REL_OFFSET	rflags,0*/
 	pushq_cfi $__KERNEL_CS /* cs */
 	/*CFI_REL_OFFSET	cs,0*/
 	pushq_cfi \child_rip /* rip */
 	CFI_REL_OFFSET	rip,0
 	pushq_cfi %rax /* orig rax */
 	.endm
 	.macro UNFAKE_STACK_FRAME
 	addq $8*6, %rsp
 	CFI_ADJUST_CFA_OFFSET	-(6*8)
 	.endm
 /*
  * initial frame state for interrupts (and exceptions without error code)
  */
 	.macro EMPTY_FRAME start=1 offset=0
 	.if \start
 	CFI_STARTPROC simple
 	CFI_SIGNAL_FRAME
 	CFI_DEF_CFA rsp,8+\offset
 	.else
 	CFI_DEF_CFA_OFFSET 8+\offset
 	.endif
 	.endm
 /*
  * initial frame state for interrupts (and exceptions without error code)
  */
 	.macro INTR_FRAME start=1 offset=0
 	EMPTY_FRAME \start, SS+8+\offset-RIP
 	/*CFI_REL_OFFSET ss, SS+\offset-RIP*/
 	CFI_REL_OFFSET rsp, RSP+\offset-RIP
 	/*CFI_REL_OFFSET rflags, EFLAGS+\offset-RIP*/
 	/*CFI_REL_OFFSET cs, CS+\offset-RIP*/
 	CFI_REL_OFFSET rip, RIP+\offset-RIP
 	.endm
 /*
  * initial frame state for exceptions with error code (and interrupts
  * with vector already pushed)
  */
 	.macro XCPT_FRAME start=1 offset=0
 	INTR_FRAME \start, RIP+\offset-ORIG_RAX
 	/*CFI_REL_OFFSET orig_rax, ORIG_RAX-ORIG_RAX*/
 	.endm
 /*
  * frame that enables calling into C.
  */
 	.macro PARTIAL_FRAME start=1 offset=0
 	XCPT_FRAME \start, ORIG_RAX+\offset-ARGOFFSET
 	CFI_REL_OFFSET rdi, RDI+\offset-ARGOFFSET
 	CFI_REL_OFFSET rsi, RSI+\offset-ARGOFFSET
 	CFI_REL_OFFSET rdx, RDX+\offset-ARGOFFSET
 	CFI_REL_OFFSET rcx, RCX+\offset-ARGOFFSET
 	CFI_REL_OFFSET rax, RAX+\offset-ARGOFFSET
 	CFI_REL_OFFSET r8, R8+\offset-ARGOFFSET
 	CFI_REL_OFFSET r9, R9+\offset-ARGOFFSET
 	CFI_REL_OFFSET r10, R10+\offset-ARGOFFSET
 	CFI_REL_OFFSET r11, R11+\offset-ARGOFFSET
 	.endm
 /*
  * frame that enables passing a complete pt_regs to a C function.
  */
 	.macro DEFAULT_FRAME start=1 offset=0
 	PARTIAL_FRAME \start, R11+\offset-R15
 	CFI_REL_OFFSET rbx, RBX+\offset
 	CFI_REL_OFFSET rbp, RBP+\offset
 	CFI_REL_OFFSET r12, R12+\offset
 	CFI_REL_OFFSET r13, R13+\offset
 	CFI_REL_OFFSET r14, R14+\offset
 	CFI_REL_OFFSET r15, R15+\offset
 	.endm
 /* save partial stack frame */
 	.macro SAVE_ARGS_IRQ
 	cld
 	/* start from rbp in pt_regs and jump over */
 	movq_cfi rdi, (RDI-RBP)
 	movq_cfi rsi, (RSI-RBP)
 	movq_cfi rdx, (RDX-RBP)
 	movq_cfi rcx, (RCX-RBP)
 	movq_cfi rax, (RAX-RBP)
 	movq_cfi  r8,  (R8-RBP)
 	movq_cfi  r9,  (R9-RBP)
 	movq_cfi r10, (R10-RBP)
 	movq_cfi r11, (R11-RBP)
 	/* Save rbp so that we can unwind from get_irq_regs() */
 	movq_cfi rbp, 0
 	/* Save previous stack value */
 	movq %rsp, %rsi
 	leaq -RBP(%rsp),%rdi	/* arg1 for handler */
 	testl $3, CS-RBP(%rsi)
 	je 1f
 	SWAPGS
 	/*
 	 * irq_count is used to check if a CPU is already on an interrupt stack
 	 * or not. While this is essentially redundant with preempt_count it is
 	 * a little cheaper to use a separate counter in the PDA (short of
 	 * moving irq_enter into assembly, which would be too much work)
 	 */
 1:	incl PER_CPU_VAR(irq_count)
 	cmovzq PER_CPU_VAR(irq_stack_ptr),%rsp
 	CFI_DEF_CFA_REGISTER	rsi
 	/* Store previous stack value */
 	pushq %rsi
 	CFI_ESCAPE	0x0f /* DW_CFA_def_cfa_expression */, 6, \
 			0x77 /* DW_OP_breg7 */, 0, \
 			0x06 /* DW_OP_deref */, \
 			0x08 /* DW_OP_const1u */, SS+8-RBP, \
 			0x22 /* DW_OP_plus */
 	/* We entered an interrupt context - irqs are off: */
 	TRACE_IRQS_OFF
 	.endm
 ENTRY(save_rest)
 	PARTIAL_FRAME 1 (REST_SKIP+8)
 	movq 5*8+16(%rsp), %r11	/* save return address */
 	movq_cfi rbx, RBX+16
 	movq_cfi rbp, RBP+16
 	movq_cfi r12, R12+16
 	movq_cfi r13, R13+16
 	movq_cfi r14, R14+16
 	movq_cfi r15, R15+16
 	movq %r11, 8(%rsp)	/* return address */
 	FIXUP_TOP_OF_STACK %r11, 16
 	ret
 	CFI_ENDPROC
 END(save_rest)
 /* save complete stack frame */
 	.pushsection .kprobes.text, "ax"
 ENTRY(save_paranoid)
 	XCPT_FRAME 1 RDI+8
 	cld
 	movq_cfi rdi, RDI+8
 	movq_cfi rsi, RSI+8
 	movq_cfi rdx, RDX+8
 	movq_cfi rcx, RCX+8
 	movq_cfi rax, RAX+8
 	movq_cfi r8, R8+8
 	movq_cfi r9, R9+8
 	movq_cfi r10, R10+8
 	movq_cfi r11, R11+8
 	movq_cfi rbx, RBX+8
 	movq_cfi rbp, RBP+8
 	movq_cfi r12, R12+8
 	movq_cfi r13, R13+8
 	movq_cfi r14, R14+8
 	movq_cfi r15, R15+8
 	movl $1,%ebx
 	movl $MSR_GS_BASE,%ecx
 	rdmsr
 	testl %edx,%edx
 	js 1f	/* negative -> in kernel */
 	SWAPGS
 	xorl %ebx,%ebx
 1:	ret
 	CFI_ENDPROC
 END(save_paranoid)
 	.popsection
 /*
  * A newly forked process directly context switches into this address.
  *
  * rdi: prev task we switched from
  */
 ENTRY(ret_from_fork)
 	DEFAULT_FRAME
 	LOCK ; btr $TIF_FORK,TI_flags(%r8)
 	pushq_cfi $0x0002
 	popfq_cfi				# reset kernel eflags
 	call schedule_tail			# rdi: 'prev' task parameter
 	GET_THREAD_INFO(%rcx)
 	RESTORE_REST
 	testl $3, CS-ARGOFFSET(%rsp)		# from kernel_thread?
 	jz   1f
 	testl $_TIF_IA32, TI_flags(%rcx)	# 32-bit compat task needs IRET
 	jnz  int_ret_from_sys_call
 	RESTORE_TOP_OF_STACK %rdi, -ARGOFFSET
 	jmp ret_from_sys_call			# go to the SYSRET fastpath
 1:
 	subq $REST_SKIP, %rsp	# leave space for volatiles
 	CFI_ADJUST_CFA_OFFSET	REST_SKIP
 	movq %rbp, %rdi
 	call *%rbx
 	movl $0, RAX(%rsp)
 	RESTORE_REST
 	jmp int_ret_from_sys_call
 	CFI_ENDPROC
 END(ret_from_fork)
 /*
  * System call entry. Up to 6 arguments in registers are supported.
  *
  * SYSCALL does not save anything on the stack and does not change the
  * stack pointer.  However, it does mask the flags register for us, so
  * CLD and CLAC are not needed.
  */
 /*
  * Register setup:
  * rax  system call number
  * rdi  arg0
  * rcx  return address for syscall/sysret, C arg3
  * rsi  arg1
  * rdx  arg2
  * r10  arg3 	(--> moved to rcx for C)
  * r8   arg4
  * r9   arg5
  * r11  eflags for syscall/sysret, temporary for C
  * r12-r15,rbp,rbx saved by C code, not touched.
  *
  * Interrupts are off on entry.
  * Only called from user space.
  *
  * XXX	if we had a free scratch register we could save the RSP into the stack frame
  *      and report it properly in ps. Unfortunately we haven't.
  *
  * When user can change the frames always force IRET. That is because
  * it deals with uncanonical addresses better. SYSRET has trouble
  * with them due to bugs in both AMD and Intel CPUs.
  */
 ENTRY(system_call)
 	CFI_STARTPROC	simple
 	CFI_SIGNAL_FRAME
 	CFI_DEF_CFA	rsp,KERNEL_STACK_OFFSET
 	CFI_REGISTER	rip,rcx
 	/*CFI_REGISTER	rflags,r11*/
 	SWAPGS_UNSAFE_STACK
 	/*
 	 * A hypervisor implementation might want to use a label
 	 * after the swapgs, so that it can do the swapgs
 	 * for the guest and jump here on syscall.
 	 */
 GLOBAL(system_call_after_swapgs)
 	movq	%rsp,PER_CPU_VAR(old_rsp)
 	movq	PER_CPU_VAR(kernel_stack),%rsp
 	/*
 	 * No need to follow this irqs off/on section - it's straight
 	 * and short:
 	 */
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	SAVE_ARGS 8,0
 	movq  %rax,ORIG_RAX-ARGOFFSET(%rsp)
 	movq  %rcx,RIP-ARGOFFSET(%rsp)
 	CFI_REL_OFFSET rip,RIP-ARGOFFSET
 	testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jnz tracesys
 system_call_fastpath:
 #if __SYSCALL_MASK == ~0
 	cmpq $__NR_syscall_max,%rax
 #else
 	andl $__SYSCALL_MASK,%eax
 	cmpl $__NR_syscall_max,%eax
 #endif
 	ja badsys
 	movq %r10,%rcx
 	call *sys_call_table(,%rax,8)  # XXX:	 rip relative
 	movq %rax,RAX-ARGOFFSET(%rsp)
 /*
  * Syscall return path ending with SYSRET (fast path)
  * Has incomplete stack frame and undefined top of stack.
  */
 ret_from_sys_call:
 	movl $_TIF_ALLWORK_MASK,%edi
 	/* edi:	flagmask */
 sysret_check:
 	LOCKDEP_SYS_EXIT
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	movl TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET),%edx
 	andl %edi,%edx
 	jnz  sysret_careful
 	CFI_REMEMBER_STATE
 	/*
 	 * sysretq will re-enable interrupts:
 	 */
 	TRACE_IRQS_ON
 	movq RIP-ARGOFFSET(%rsp),%rcx
 	CFI_REGISTER	rip,rcx
 	RESTORE_ARGS 1,-ARG_SKIP,0
 	/*CFI_REGISTER	rflags,r11*/
 	movq	PER_CPU_VAR(old_rsp), %rsp
 	USERGS_SYSRET64
 	CFI_RESTORE_STATE
 	/* Handle reschedules */
 	/* edx:	work, edi: workmask */
 sysret_careful:
 	bt $TIF_NEED_RESCHED,%edx
 	jnc sysret_signal
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	pushq_cfi %rdi
 	SCHEDULE_USER
 	popq_cfi %rdi
 	jmp sysret_check
 	/* Handle a signal */
 sysret_signal:
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 #ifdef CONFIG_AUDITSYSCALL
 	bt $TIF_SYSCALL_AUDIT,%edx
 	jc sysret_audit
 #endif
 	/*
 	 * We have a signal, or exit tracing or single-step.
 	 * These all wind up with the iret return path anyway,
 	 * so just join that path right now.
 	 */
 	FIXUP_TOP_OF_STACK %r11, -ARGOFFSET
 	jmp int_check_syscall_exit_work
 badsys:
 	movq $-ENOSYS,RAX-ARGOFFSET(%rsp)
 	jmp ret_from_sys_call
 #ifdef CONFIG_AUDITSYSCALL
 	/*
 	 * Fast path for syscall audit without full syscall trace.
 	 * We just call __audit_syscall_entry() directly, and then
 	 * jump back to the normal fast path.
 	 */
 auditsys:
 	movq %r10,%r9			/* 6th arg: 4th syscall arg */
 	movq %rdx,%r8			/* 5th arg: 3rd syscall arg */
 	movq %rsi,%rcx			/* 4th arg: 2nd syscall arg */
 	movq %rdi,%rdx			/* 3rd arg: 1st syscall arg */
 	movq %rax,%rsi			/* 2nd arg: syscall number */
 	movl $AUDIT_ARCH_X86_64,%edi	/* 1st arg: audit arch */
 	call __audit_syscall_entry
 	LOAD_ARGS 0		/* reload call-clobbered registers */
 	jmp system_call_fastpath
 	/*
 	 * Return fast path for syscall audit.  Call __audit_syscall_exit()
 	 * directly and then jump back to the fast path with TIF_SYSCALL_AUDIT
 	 * masked off.
 	 */
 sysret_audit:
 	movq RAX-ARGOFFSET(%rsp),%rsi	/* second arg, syscall return value */
 	cmpq $-MAX_ERRNO,%rsi	/* is it < -MAX_ERRNO? */
 	setbe %al		/* 1 if so, 0 if not */
 	movzbl %al,%edi		/* zero-extend that into %edi */
 	call __audit_syscall_exit
 	movl $(_TIF_ALLWORK_MASK & ~_TIF_SYSCALL_AUDIT),%edi
 	jmp sysret_check
 #endif	/* CONFIG_AUDITSYSCALL */
 	/* Do syscall tracing */
 tracesys:
 #ifdef CONFIG_AUDITSYSCALL
 	testl $(_TIF_WORK_SYSCALL_ENTRY & ~_TIF_SYSCALL_AUDIT),TI_flags+THREAD_INFO(%rsp,RIP-ARGOFFSET)
 	jz auditsys
 #endif
 	SAVE_REST
 	movq $-ENOSYS,RAX(%rsp) /* ptrace can change this for a bad syscall */
 	FIXUP_TOP_OF_STACK %rdi
 	movq %rsp,%rdi
 	call syscall_trace_enter
 	/*
 	 * Reload arg registers from stack in case ptrace changed them.
 	 * We don't reload %rax because syscall_trace_enter() returned
 	 * the value it wants us to use in the table lookup.
 	 */
 	LOAD_ARGS ARGOFFSET, 1
 	RESTORE_REST
 #if __SYSCALL_MASK == ~0
 	cmpq $__NR_syscall_max,%rax
 #else
 	andl $__SYSCALL_MASK,%eax
 	cmpl $__NR_syscall_max,%eax
 #endif
 	ja   int_ret_from_sys_call	/* RAX(%rsp) set to -ENOSYS above */
 	movq %r10,%rcx	/* fixup for C */
 	call *sys_call_table(,%rax,8)
 	movq %rax,RAX-ARGOFFSET(%rsp)
 	/* Use IRET because user could have changed frame */
 /*
  * Syscall return path ending with IRET.
  * Has correct top of stack, but partial stack frame.
  */
 GLOBAL(int_ret_from_sys_call)
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	movl $_TIF_ALLWORK_MASK,%edi
 	/* edi:	mask to check */
 GLOBAL(int_with_check)
 	LOCKDEP_SYS_EXIT_IRQ
 	GET_THREAD_INFO(%rcx)
 	movl TI_flags(%rcx),%edx
 	andl %edi,%edx
 	jnz   int_careful
 	andl    $~TS_COMPAT,TI_status(%rcx)
 	jmp   retint_swapgs
 	/* Either reschedule or signal or syscall exit tracking needed. */
 	/* First do a reschedule test. */
 	/* edx:	work, edi: workmask */
 int_careful:
 	bt $TIF_NEED_RESCHED,%edx
 	jnc  int_very_careful
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	pushq_cfi %rdi
 	SCHEDULE_USER
 	popq_cfi %rdi
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	jmp int_with_check
 	/* handle signals and tracing -- both require a full stack frame */
 int_very_careful:
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 int_check_syscall_exit_work:
 	SAVE_REST
 	/* Check for syscall exit trace */
 	testl $_TIF_WORK_SYSCALL_EXIT,%edx
 	jz int_signal
 	pushq_cfi %rdi
 	leaq 8(%rsp),%rdi	# &ptregs -> arg1
 	call syscall_trace_leave
 	popq_cfi %rdi
 	andl $~(_TIF_WORK_SYSCALL_EXIT|_TIF_SYSCALL_EMU),%edi
 	jmp int_restore_rest
 int_signal:
 	testl $_TIF_DO_NOTIFY_MASK,%edx
 	jz 1f
 	movq %rsp,%rdi		# &ptregs -> arg1
 	xorl %esi,%esi		# oldset -> arg2
 	call do_notify_resume
 1:	movl $_TIF_WORK_MASK,%edi
 int_restore_rest:
 	RESTORE_REST
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	jmp int_with_check
 	CFI_ENDPROC
 END(system_call)
 /*
  * Certain special system calls that need to save a complete full stack frame.
  */
 	.macro PTREGSCALL label,func,arg
 ENTRY(\label)
 	PARTIAL_FRAME 1 8		/* offset 8: return address */
 	subq $REST_SKIP, %rsp
 	CFI_ADJUST_CFA_OFFSET REST_SKIP
 	call save_rest
 	DEFAULT_FRAME 0 8		/* offset 8: return address */
 	leaq 8(%rsp), \arg	/* pt_regs pointer */
 	call \func
 	jmp ptregscall_common
 	CFI_ENDPROC
 END(\label)
 	.endm
 	.macro FORK_LIKE func
 ENTRY(stub_\func)
 	CFI_STARTPROC
 	popq	%r11			/* save return address */
 	PARTIAL_FRAME 0
 	SAVE_REST
 	pushq	%r11			/* put it back on stack */
 	FIXUP_TOP_OF_STACK %r11, 8
 	DEFAULT_FRAME 0 8		/* offset 8: return address */
 	call sys_\func
 	RESTORE_TOP_OF_STACK %r11, 8
 	ret $REST_SKIP		/* pop extended registers */
 	CFI_ENDPROC
 END(stub_\func)
 	.endm
 	FORK_LIKE  clone
 	FORK_LIKE  fork
 	FORK_LIKE  vfork
 	PTREGSCALL stub_iopl, sys_iopl, %rsi
 ENTRY(ptregscall_common)
 	DEFAULT_FRAME 1 8	/* offset 8: return address */
 	RESTORE_TOP_OF_STACK %r11, 8
 	movq_cfi_restore R15+8, r15
 	movq_cfi_restore R14+8, r14
 	movq_cfi_restore R13+8, r13
 	movq_cfi_restore R12+8, r12
 	movq_cfi_restore RBP+8, rbp
 	movq_cfi_restore RBX+8, rbx
 	ret $REST_SKIP		/* pop extended registers */
 	CFI_ENDPROC
 END(ptregscall_common)
 ENTRY(stub_execve)
 	CFI_STARTPROC
 	addq $8, %rsp
 	PARTIAL_FRAME 0
 	SAVE_REST
 	FIXUP_TOP_OF_STACK %r11
 	call sys_execve
 	RESTORE_TOP_OF_STACK %r11
 	movq %rax,RAX(%rsp)
 	RESTORE_REST
 	jmp int_ret_from_sys_call
 	CFI_ENDPROC
 END(stub_execve)
 /*
  * sigreturn is special because it needs to restore all registers on return.
  * This cannot be done with SYSRET, so use the IRET return path instead.
  */
 ENTRY(stub_rt_sigreturn)
 	CFI_STARTPROC
 	addq $8, %rsp
 	PARTIAL_FRAME 0
 	SAVE_REST
 	movq %rsp,%rdi
 	FIXUP_TOP_OF_STACK %r11
 	call sys_rt_sigreturn
 	movq %rax,RAX(%rsp) # fixme, this could be done at the higher layer
 	RESTORE_REST
 	jmp int_ret_from_sys_call
 	CFI_ENDPROC
 END(stub_rt_sigreturn)
 #ifdef CONFIG_X86_X32_ABI
-	PTREGSCALL stub_x32_sigaltstack, sys32_sigaltstack, %rdx
 ENTRY(stub_x32_rt_sigreturn)
 	CFI_STARTPROC
 	addq $8, %rsp
 	PARTIAL_FRAME 0
 	SAVE_REST
 	movq %rsp,%rdi
 	FIXUP_TOP_OF_STACK %r11
 	call sys32_x32_rt_sigreturn
 	movq %rax,RAX(%rsp) # fixme, this could be done at the higher layer
 	RESTORE_REST
 	jmp int_ret_from_sys_call
 	CFI_ENDPROC
 END(stub_x32_rt_sigreturn)
 ENTRY(stub_x32_execve)
 	CFI_STARTPROC
 	addq $8, %rsp
 	PARTIAL_FRAME 0
 	SAVE_REST
 	FIXUP_TOP_OF_STACK %r11
 	call compat_sys_execve
 	RESTORE_TOP_OF_STACK %r11
 	movq %rax,RAX(%rsp)
 	RESTORE_REST
 	jmp int_ret_from_sys_call
 	CFI_ENDPROC
 END(stub_x32_execve)
 #endif
 /*
  * Build the entry stubs and pointer table with some assembler magic.
  * We pack 7 stubs into a single 32-byte chunk, which will fit in a
  * single cache line on all modern x86 implementations.
  */
 	.section .init.rodata,"a"
 ENTRY(interrupt)
 	.section .entry.text
 	.p2align 5
 	.p2align CONFIG_X86_L1_CACHE_SHIFT
 ENTRY(irq_entries_start)
 	INTR_FRAME
 vector=FIRST_EXTERNAL_VECTOR
 .rept (NR_VECTORS-FIRST_EXTERNAL_VECTOR+6)/7
 	.balign 32
   .rept	7
     .if vector < NR_VECTORS
       .if vector <> FIRST_EXTERNAL_VECTOR
 	CFI_ADJUST_CFA_OFFSET -8
       .endif
 1:	pushq_cfi $(~vector+0x80)	/* Note: always in signed byte range */
       .if ((vector-FIRST_EXTERNAL_VECTOR)%7) <> 6
 	jmp 2f
       .endif
       .previous
 	.quad 1b
       .section .entry.text
 vector=vector+1
     .endif
   .endr
 2:	jmp common_interrupt
 .endr
 	CFI_ENDPROC
 END(irq_entries_start)
 .previous
 END(interrupt)
 .previous
 /*
  * Interrupt entry/exit.
  *
  * Interrupt entry points save only callee clobbered registers in fast path.
  *
  * Entry runs with interrupts off.
  */
 /* 0(%rsp): ~(interrupt number) */
 	.macro interrupt func
 	/* reserve pt_regs for scratch regs and rbp */
 	subq $ORIG_RAX-RBP, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-RBP
 	SAVE_ARGS_IRQ
 	call \func
 	.endm
 /*
  * Interrupt entry/exit should be protected against kprobes
  */
 	.pushsection .kprobes.text, "ax"
 	/*
 	 * The interrupt stubs push (~vector+0x80) onto the stack and
 	 * then jump to common_interrupt.
 	 */
 	.p2align CONFIG_X86_L1_CACHE_SHIFT
 common_interrupt:
 	XCPT_FRAME
 	ASM_CLAC
 	addq $-0x80,(%rsp)		/* Adjust vector to [-256,-1] range */
 	interrupt do_IRQ
 	/* 0(%rsp): old_rsp-ARGOFFSET */
 ret_from_intr:
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	decl PER_CPU_VAR(irq_count)
 	/* Restore saved previous stack */
 	popq %rsi
 	CFI_DEF_CFA rsi,SS+8-RBP	/* reg/off reset after def_cfa_expr */
 	leaq ARGOFFSET-RBP(%rsi), %rsp
 	CFI_DEF_CFA_REGISTER	rsp
 	CFI_ADJUST_CFA_OFFSET	RBP-ARGOFFSET
 exit_intr:
 	GET_THREAD_INFO(%rcx)
 	testl $3,CS-ARGOFFSET(%rsp)
 	je retint_kernel
 	/* Interrupt came from user space */
 	/*
 	 * Has a correct top of stack, but a partial stack frame
 	 * %rcx: thread info. Interrupts off.
 	 */
 retint_with_reschedule:
 	movl $_TIF_WORK_MASK,%edi
 retint_check:
 	LOCKDEP_SYS_EXIT_IRQ
 	movl TI_flags(%rcx),%edx
 	andl %edi,%edx
 	CFI_REMEMBER_STATE
 	jnz  retint_careful
 retint_swapgs:		/* return to user-space */
 	/*
 	 * The iretq could re-enable interrupts:
 	 */
 	DISABLE_INTERRUPTS(CLBR_ANY)
 	TRACE_IRQS_IRETQ
 	SWAPGS
 	jmp restore_args
 retint_restore_args:	/* return to kernel space */
 	DISABLE_INTERRUPTS(CLBR_ANY)
 	/*
 	 * The iretq could re-enable interrupts:
 	 */
 	TRACE_IRQS_IRETQ
 restore_args:
 	RESTORE_ARGS 1,8,1
 irq_return:
 	INTERRUPT_RETURN
 	_ASM_EXTABLE(irq_return, bad_iret)
 #ifdef CONFIG_PARAVIRT
 ENTRY(native_iret)
 	iretq
 	_ASM_EXTABLE(native_iret, bad_iret)
 #endif
 	.section .fixup,"ax"
 bad_iret:
 	/*
 	 * The iret traps when the %cs or %ss being restored is bogus.
 	 * We've lost the original trap vector and error code.
 	 * #GPF is the most likely one to get for an invalid selector.
 	 * So pretend we completed the iret and took the #GPF in user mode.
 	 *
 	 * We are now running with the kernel GS after exception recovery.
 	 * But error_entry expects us to have user GS to match the user %cs,
 	 * so swap back.
 	 */
 	pushq $0
 	SWAPGS
 	jmp general_protection
 	.previous
 	/* edi: workmask, edx: work */
 retint_careful:
 	CFI_RESTORE_STATE
 	bt    $TIF_NEED_RESCHED,%edx
 	jnc   retint_signal
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	pushq_cfi %rdi
 	SCHEDULE_USER
 	popq_cfi %rdi
 	GET_THREAD_INFO(%rcx)
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	jmp retint_check
 retint_signal:
 	testl $_TIF_DO_NOTIFY_MASK,%edx
 	jz    retint_swapgs
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	SAVE_REST
 	movq $-1,ORIG_RAX(%rsp)
 	xorl %esi,%esi		# oldset
 	movq %rsp,%rdi		# &pt_regs
 	call do_notify_resume
 	RESTORE_REST
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	GET_THREAD_INFO(%rcx)
 	jmp retint_with_reschedule
 #ifdef CONFIG_PREEMPT
 	/* Returning to kernel space. Check if we need preemption */
 	/* rcx:	 threadinfo. interrupts off. */
 ENTRY(retint_kernel)
 	cmpl $0,TI_preempt_count(%rcx)
 	jnz  retint_restore_args
 	bt  $TIF_NEED_RESCHED,TI_flags(%rcx)
 	jnc  retint_restore_args
 	bt   $9,EFLAGS-ARGOFFSET(%rsp)	/* interrupts off? */
 	jnc  retint_restore_args
 	call preempt_schedule_irq
 	jmp exit_intr
 #endif
 	CFI_ENDPROC
 END(common_interrupt)
 /*
  * End of kprobes section
  */
        .popsection
 /*
  * APIC interrupts.
  */
 .macro apicinterrupt num sym do_sym
 ENTRY(\sym)
 	INTR_FRAME
 	ASM_CLAC
 	pushq_cfi $~(\num)
 .Lcommon_\sym:
 	interrupt \do_sym
 	jmp ret_from_intr
 	CFI_ENDPROC
 END(\sym)
 .endm
 #ifdef CONFIG_SMP
 apicinterrupt IRQ_MOVE_CLEANUP_VECTOR \
 	irq_move_cleanup_interrupt smp_irq_move_cleanup_interrupt
 apicinterrupt REBOOT_VECTOR \
 	reboot_interrupt smp_reboot_interrupt
 #endif
 #ifdef CONFIG_X86_UV
 apicinterrupt UV_BAU_MESSAGE \
 	uv_bau_message_intr1 uv_bau_message_interrupt
 #endif
 apicinterrupt LOCAL_TIMER_VECTOR \
 	apic_timer_interrupt smp_apic_timer_interrupt
 apicinterrupt X86_PLATFORM_IPI_VECTOR \
 	x86_platform_ipi smp_x86_platform_ipi
 apicinterrupt THRESHOLD_APIC_VECTOR \
 	threshold_interrupt smp_threshold_interrupt
 apicinterrupt THERMAL_APIC_VECTOR \
 	thermal_interrupt smp_thermal_interrupt
 #ifdef CONFIG_SMP
 apicinterrupt CALL_FUNCTION_SINGLE_VECTOR \
 	call_function_single_interrupt smp_call_function_single_interrupt
 apicinterrupt CALL_FUNCTION_VECTOR \
 	call_function_interrupt smp_call_function_interrupt
 apicinterrupt RESCHEDULE_VECTOR \
 	reschedule_interrupt smp_reschedule_interrupt
 #endif
 apicinterrupt ERROR_APIC_VECTOR \
 	error_interrupt smp_error_interrupt
 apicinterrupt SPURIOUS_APIC_VECTOR \
 	spurious_interrupt smp_spurious_interrupt
 #ifdef CONFIG_IRQ_WORK
 apicinterrupt IRQ_WORK_VECTOR \
 	irq_work_interrupt smp_irq_work_interrupt
 #endif
 /*
  * Exception entry points.
  */
 .macro zeroentry sym do_sym
 ENTRY(\sym)
 	INTR_FRAME
 	ASM_CLAC
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	pushq_cfi $-1		/* ORIG_RAX: no syscall to restart */
 	subq $ORIG_RAX-R15, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
 	call error_entry
 	DEFAULT_FRAME 0
 	movq %rsp,%rdi		/* pt_regs pointer */
 	xorl %esi,%esi		/* no error code */
 	call \do_sym
 	jmp error_exit		/* %ebx: no swapgs flag */
 	CFI_ENDPROC
 END(\sym)
 .endm
 .macro paranoidzeroentry sym do_sym
 ENTRY(\sym)
 	INTR_FRAME
 	ASM_CLAC
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	pushq_cfi $-1		/* ORIG_RAX: no syscall to restart */
 	subq $ORIG_RAX-R15, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
 	call save_paranoid
 	TRACE_IRQS_OFF
 	movq %rsp,%rdi		/* pt_regs pointer */
 	xorl %esi,%esi		/* no error code */
 	call \do_sym
 	jmp paranoid_exit	/* %ebx: no swapgs flag */
 	CFI_ENDPROC
 END(\sym)
 .endm
 #define INIT_TSS_IST(x) PER_CPU_VAR(init_tss) + (TSS_ist + ((x) - 1) * 8)
 .macro paranoidzeroentry_ist sym do_sym ist
 ENTRY(\sym)
 	INTR_FRAME
 	ASM_CLAC
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	pushq_cfi $-1		/* ORIG_RAX: no syscall to restart */
 	subq $ORIG_RAX-R15, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
 	call save_paranoid
 	TRACE_IRQS_OFF_DEBUG
 	movq %rsp,%rdi		/* pt_regs pointer */
 	xorl %esi,%esi		/* no error code */
 	subq $EXCEPTION_STKSZ, INIT_TSS_IST(\ist)
 	call \do_sym
 	addq $EXCEPTION_STKSZ, INIT_TSS_IST(\ist)
 	jmp paranoid_exit	/* %ebx: no swapgs flag */
 	CFI_ENDPROC
 END(\sym)
 .endm
 .macro errorentry sym do_sym
 ENTRY(\sym)
 	XCPT_FRAME
 	ASM_CLAC
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	subq $ORIG_RAX-R15, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
 	call error_entry
 	DEFAULT_FRAME 0
 	movq %rsp,%rdi			/* pt_regs pointer */
 	movq ORIG_RAX(%rsp),%rsi	/* get error code */
 	movq $-1,ORIG_RAX(%rsp)		/* no syscall to restart */
 	call \do_sym
 	jmp error_exit			/* %ebx: no swapgs flag */
 	CFI_ENDPROC
 END(\sym)
 .endm
 	/* error code is on the stack already */
 .macro paranoiderrorentry sym do_sym
 ENTRY(\sym)
 	XCPT_FRAME
 	ASM_CLAC
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	subq $ORIG_RAX-R15, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
 	call save_paranoid
 	DEFAULT_FRAME 0
 	TRACE_IRQS_OFF
 	movq %rsp,%rdi			/* pt_regs pointer */
 	movq ORIG_RAX(%rsp),%rsi	/* get error code */
 	movq $-1,ORIG_RAX(%rsp)		/* no syscall to restart */
 	call \do_sym
 	jmp paranoid_exit		/* %ebx: no swapgs flag */
 	CFI_ENDPROC
 END(\sym)
 .endm
 zeroentry divide_error do_divide_error
 zeroentry overflow do_overflow
 zeroentry bounds do_bounds
 zeroentry invalid_op do_invalid_op
 zeroentry device_not_available do_device_not_available
 paranoiderrorentry double_fault do_double_fault
 zeroentry coprocessor_segment_overrun do_coprocessor_segment_overrun
 errorentry invalid_TSS do_invalid_TSS
 errorentry segment_not_present do_segment_not_present
 zeroentry spurious_interrupt_bug do_spurious_interrupt_bug
 zeroentry coprocessor_error do_coprocessor_error
 errorentry alignment_check do_alignment_check
 zeroentry simd_coprocessor_error do_simd_coprocessor_error
 	/* Reload gs selector with exception handling */
 	/* edi:  new selector */
 ENTRY(native_load_gs_index)
 	CFI_STARTPROC
 	pushfq_cfi
 	DISABLE_INTERRUPTS(CLBR_ANY & ~CLBR_RDI)
 	SWAPGS
 gs_change:
 	movl %edi,%gs
 2:	mfence		/* workaround */
 	SWAPGS
 	popfq_cfi
 	ret
 	CFI_ENDPROC
 END(native_load_gs_index)
 	_ASM_EXTABLE(gs_change,bad_gs)
 	.section .fixup,"ax"
 	/* running with kernelgs */
 bad_gs:
 	SWAPGS			/* switch back to user gs */
 	xorl %eax,%eax
 	movl %eax,%gs
 	jmp  2b
 	.previous
 /* Call softirq on interrupt stack. Interrupts are off. */
 ENTRY(call_softirq)
 	CFI_STARTPROC
 	pushq_cfi %rbp
 	CFI_REL_OFFSET rbp,0
 	mov  %rsp,%rbp
 	CFI_DEF_CFA_REGISTER rbp
 	incl PER_CPU_VAR(irq_count)
 	cmove PER_CPU_VAR(irq_stack_ptr),%rsp
 	push  %rbp			# backlink for old unwinder
 	call __do_softirq
 	leaveq
 	CFI_RESTORE		rbp
 	CFI_DEF_CFA_REGISTER	rsp
 	CFI_ADJUST_CFA_OFFSET   -8
 	decl PER_CPU_VAR(irq_count)
 	ret
 	CFI_ENDPROC
 END(call_softirq)
 #ifdef CONFIG_XEN
 zeroentry xen_hypervisor_callback xen_do_hypervisor_callback
 /*
  * A note on the "critical region" in our callback handler.
  * We want to avoid stacking callback handlers due to events occurring
  * during handling of the last event. To do this, we keep events disabled
  * until we've done all processing. HOWEVER, we must enable events before
  * popping the stack frame (can't be done atomically) and so it would still
  * be possible to get enough handler activations to overflow the stack.
  * Although unlikely, bugs of that kind are hard to track down, so we'd
  * like to avoid the possibility.
  * So, on entry to the handler we detect whether we interrupted an
  * existing activation in its critical region -- if so, we pop the current
  * activation and restart the handler using the previous one.
  */
 ENTRY(xen_do_hypervisor_callback)   # do_hypervisor_callback(struct *pt_regs)
 	CFI_STARTPROC
 /*
  * Since we don't modify %rdi, evtchn_do_upall(struct *pt_regs) will
  * see the correct pointer to the pt_regs
  */
 	movq %rdi, %rsp            # we don't return, adjust the stack frame
 	CFI_ENDPROC
 	DEFAULT_FRAME
 11:	incl PER_CPU_VAR(irq_count)
 	movq %rsp,%rbp
 	CFI_DEF_CFA_REGISTER rbp
 	cmovzq PER_CPU_VAR(irq_stack_ptr),%rsp
 	pushq %rbp			# backlink for old unwinder
 	call xen_evtchn_do_upcall
 	popq %rsp
 	CFI_DEF_CFA_REGISTER rsp
 	decl PER_CPU_VAR(irq_count)
 	jmp  error_exit
 	CFI_ENDPROC
 END(xen_do_hypervisor_callback)
 /*
  * Hypervisor uses this for application faults while it executes.
  * We get here for two reasons:
  *  1. Fault while reloading DS, ES, FS or GS
  *  2. Fault while executing IRET
  * Category 1 we do not need to fix up as Xen has already reloaded all segment
  * registers that could be reloaded and zeroed the others.
  * Category 2 we fix up by killing the current process. We cannot use the
  * normal Linux return path in this case because if we use the IRET hypercall
  * to pop the stack frame we end up in an infinite loop of failsafe callbacks.
  * We distinguish between categories by comparing each saved segment register
  * with its current contents: any discrepancy means we in category 1.
  */
 ENTRY(xen_failsafe_callback)
 	INTR_FRAME 1 (6*8)
 	/*CFI_REL_OFFSET gs,GS*/
 	/*CFI_REL_OFFSET fs,FS*/
 	/*CFI_REL_OFFSET es,ES*/
 	/*CFI_REL_OFFSET ds,DS*/
 	CFI_REL_OFFSET r11,8
 	CFI_REL_OFFSET rcx,0
 	movw %ds,%cx
 	cmpw %cx,0x10(%rsp)
 	CFI_REMEMBER_STATE
 	jne 1f
 	movw %es,%cx
 	cmpw %cx,0x18(%rsp)
 	jne 1f
 	movw %fs,%cx
 	cmpw %cx,0x20(%rsp)
 	jne 1f
 	movw %gs,%cx
 	cmpw %cx,0x28(%rsp)
 	jne 1f
 	/* All segments match their saved values => Category 2 (Bad IRET). */
 	movq (%rsp),%rcx
 	CFI_RESTORE rcx
 	movq 8(%rsp),%r11
 	CFI_RESTORE r11
 	addq $0x30,%rsp
 	CFI_ADJUST_CFA_OFFSET -0x30
 	pushq_cfi $0	/* RIP */
 	pushq_cfi %r11
 	pushq_cfi %rcx
 	jmp general_protection
 	CFI_RESTORE_STATE
 1:	/* Segment mismatch => Category 1 (Bad segment). Retry the IRET. */
 	movq (%rsp),%rcx
 	CFI_RESTORE rcx
 	movq 8(%rsp),%r11
 	CFI_RESTORE r11
 	addq $0x30,%rsp
 	CFI_ADJUST_CFA_OFFSET -0x30
 	pushq_cfi $-1 /* orig_ax = -1 => not a system call */
 	SAVE_ALL
 	jmp error_exit
 	CFI_ENDPROC
 END(xen_failsafe_callback)
 apicinterrupt XEN_HVM_EVTCHN_CALLBACK \
 	xen_hvm_callback_vector xen_evtchn_do_upcall
 #endif /* CONFIG_XEN */
 /*
  * Some functions should be protected against kprobes
  */
 	.pushsection .kprobes.text, "ax"
 paranoidzeroentry_ist debug do_debug DEBUG_STACK
 paranoidzeroentry_ist int3 do_int3 DEBUG_STACK
 paranoiderrorentry stack_segment do_stack_segment
 #ifdef CONFIG_XEN
 zeroentry xen_debug do_debug
 zeroentry xen_int3 do_int3
 errorentry xen_stack_segment do_stack_segment
 #endif
 errorentry general_protection do_general_protection
 errorentry page_fault do_page_fault
 #ifdef CONFIG_KVM_GUEST
 errorentry async_page_fault do_async_page_fault
 #endif
 #ifdef CONFIG_X86_MCE
 paranoidzeroentry machine_check *machine_check_vector(%rip)
 #endif
 	/*
 	 * "Paranoid" exit path from exception stack.
 	 * Paranoid because this is used by NMIs and cannot take
 	 * any kernel state for granted.
 	 * We don't do kernel preemption checks here, because only
 	 * NMI should be common and it does not enable IRQs and
 	 * cannot get reschedule ticks.
 	 *
 	 * "trace" is 0 for the NMI handler only, because irq-tracing
 	 * is fundamentally NMI-unsafe. (we cannot change the soft and
 	 * hard flags at once, atomically)
 	 */
 	/* ebx:	no swapgs flag */
 ENTRY(paranoid_exit)
 	DEFAULT_FRAME
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF_DEBUG
 	testl %ebx,%ebx				/* swapgs needed? */
 	jnz paranoid_restore
 	testl $3,CS(%rsp)
 	jnz   paranoid_userspace
 paranoid_swapgs:
 	TRACE_IRQS_IRETQ 0
 	SWAPGS_UNSAFE_STACK
 	RESTORE_ALL 8
 	jmp irq_return
 paranoid_restore:
 	TRACE_IRQS_IRETQ_DEBUG 0
 	RESTORE_ALL 8
 	jmp irq_return
 paranoid_userspace:
 	GET_THREAD_INFO(%rcx)
 	movl TI_flags(%rcx),%ebx
 	andl $_TIF_WORK_MASK,%ebx
 	jz paranoid_swapgs
 	movq %rsp,%rdi			/* &pt_regs */
 	call sync_regs
 	movq %rax,%rsp			/* switch stack for scheduling */
 	testl $_TIF_NEED_RESCHED,%ebx
 	jnz paranoid_schedule
 	movl %ebx,%edx			/* arg3: thread flags */
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_NONE)
 	xorl %esi,%esi 			/* arg2: oldset */
 	movq %rsp,%rdi 			/* arg1: &pt_regs */
 	call do_notify_resume
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	jmp paranoid_userspace
 paranoid_schedule:
 	TRACE_IRQS_ON
 	ENABLE_INTERRUPTS(CLBR_ANY)
 	SCHEDULE_USER
 	DISABLE_INTERRUPTS(CLBR_ANY)
 	TRACE_IRQS_OFF
 	jmp paranoid_userspace
 	CFI_ENDPROC
 END(paranoid_exit)
 /*
  * Exception entry point. This expects an error code/orig_rax on the stack.
  * returns in "no swapgs flag" in %ebx.
  */
 ENTRY(error_entry)
 	XCPT_FRAME
 	CFI_ADJUST_CFA_OFFSET 15*8
 	/* oldrax contains error code */
 	cld
 	movq_cfi rdi, RDI+8
 	movq_cfi rsi, RSI+8
 	movq_cfi rdx, RDX+8
 	movq_cfi rcx, RCX+8
 	movq_cfi rax, RAX+8
 	movq_cfi  r8,  R8+8
 	movq_cfi  r9,  R9+8
 	movq_cfi r10, R10+8
 	movq_cfi r11, R11+8
 	movq_cfi rbx, RBX+8
 	movq_cfi rbp, RBP+8
 	movq_cfi r12, R12+8
 	movq_cfi r13, R13+8
 	movq_cfi r14, R14+8
 	movq_cfi r15, R15+8
 	xorl %ebx,%ebx
 	testl $3,CS+8(%rsp)
 	je error_kernelspace
 error_swapgs:
 	SWAPGS
 error_sti:
 	TRACE_IRQS_OFF
 	ret
 /*
  * There are two places in the kernel that can potentially fault with
  * usergs. Handle them here. The exception handlers after iret run with
  * kernel gs again, so don't set the user space flag. B stepping K8s
  * sometimes report an truncated RIP for IRET exceptions returning to
  * compat mode. Check for these here too.
  */
 error_kernelspace:
 	incl %ebx
 	leaq irq_return(%rip),%rcx
 	cmpq %rcx,RIP+8(%rsp)
 	je error_swapgs
 	movl %ecx,%eax	/* zero extend */
 	cmpq %rax,RIP+8(%rsp)
 	je bstep_iret
 	cmpq $gs_change,RIP+8(%rsp)
 	je error_swapgs
 	jmp error_sti
 bstep_iret:
 	/* Fix truncated RIP */
 	movq %rcx,RIP+8(%rsp)
 	jmp error_swapgs
 	CFI_ENDPROC
 END(error_entry)
 /* ebx:	no swapgs flag (1: don't need swapgs, 0: need it) */
 ENTRY(error_exit)
 	DEFAULT_FRAME
 	movl %ebx,%eax
 	RESTORE_REST
 	DISABLE_INTERRUPTS(CLBR_NONE)
 	TRACE_IRQS_OFF
 	GET_THREAD_INFO(%rcx)
 	testl %eax,%eax
 	jne retint_kernel
 	LOCKDEP_SYS_EXIT_IRQ
 	movl TI_flags(%rcx),%edx
 	movl $_TIF_WORK_MASK,%edi
 	andl %edi,%edx
 	jnz retint_careful
 	jmp retint_swapgs
 	CFI_ENDPROC
 END(error_exit)
 /*
  * Test if a given stack is an NMI stack or not.
  */
 	.macro test_in_nmi reg stack nmi_ret normal_ret
 	cmpq %\reg, \stack
 	ja \normal_ret
 	subq $EXCEPTION_STKSZ, %\reg
 	cmpq %\reg, \stack
 	jb \normal_ret
 	jmp \nmi_ret
 	.endm
 	/* runs on exception stack */
 ENTRY(nmi)
 	INTR_FRAME
 	PARAVIRT_ADJUST_EXCEPTION_FRAME
 	/*
 	 * We allow breakpoints in NMIs. If a breakpoint occurs, then
 	 * the iretq it performs will take us out of NMI context.
 	 * This means that we can have nested NMIs where the next
 	 * NMI is using the top of the stack of the previous NMI. We
 	 * can't let it execute because the nested NMI will corrupt the
 	 * stack of the previous NMI. NMI handlers are not re-entrant
 	 * anyway.
 	 *
 	 * To handle this case we do the following:
 	 *  Check the a special location on the stack that contains
 	 *  a variable that is set when NMIs are executing.
 	 *  The interrupted task's stack is also checked to see if it
 	 *  is an NMI stack.
 	 *  If the variable is not set and the stack is not the NMI
 	 *  stack then:
 	 *    o Set the special variable on the stack
 	 *    o Copy the interrupt frame into a "saved" location on the stack
 	 *    o Copy the interrupt frame into a "copy" location on the stack
 	 *    o Continue processing the NMI
 	 *  If the variable is set or the previous stack is the NMI stack:
 	 *    o Modify the "copy" location to jump to the repeate_nmi
 	 *    o return back to the first NMI
 	 *
 	 * Now on exit of the first NMI, we first clear the stack variable
 	 * The NMI stack will tell any nested NMIs at that point that it is
 	 * nested. Then we pop the stack normally with iret, and if there was
 	 * a nested NMI that updated the copy interrupt stack frame, a
 	 * jump will be made to the repeat_nmi code that will handle the second
 	 * NMI.
 	 */
 	/* Use %rdx as out temp variable throughout */
 	pushq_cfi %rdx
 	CFI_REL_OFFSET rdx, 0
 	/*
 	 * If %cs was not the kernel segment, then the NMI triggered in user
 	 * space, which means it is definitely not nested.
 	 */
 	cmpl $__KERNEL_CS, 16(%rsp)
 	jne first_nmi
 	/*
 	 * Check the special variable on the stack to see if NMIs are
 	 * executing.
 	 */
 	cmpl $1, -8(%rsp)
 	je nested_nmi
 	/*
 	 * Now test if the previous stack was an NMI stack.
 	 * We need the double check. We check the NMI stack to satisfy the
 	 * race when the first NMI clears the variable before returning.
 	 * We check the variable because the first NMI could be in a
 	 * breakpoint routine using a breakpoint stack.
 	 */
 	lea 6*8(%rsp), %rdx
 	test_in_nmi rdx, 4*8(%rsp), nested_nmi, first_nmi
 	CFI_REMEMBER_STATE
 nested_nmi:
 	/*
 	 * Do nothing if we interrupted the fixup in repeat_nmi.
 	 * It's about to repeat the NMI handler, so we are fine
 	 * with ignoring this one.
 	 */
 	movq $repeat_nmi, %rdx
 	cmpq 8(%rsp), %rdx
 	ja 1f
 	movq $end_repeat_nmi, %rdx
 	cmpq 8(%rsp), %rdx
 	ja nested_nmi_out
 1:
 	/* Set up the interrupted NMIs stack to jump to repeat_nmi */
 	leaq -6*8(%rsp), %rdx
 	movq %rdx, %rsp
 	CFI_ADJUST_CFA_OFFSET 6*8
 	pushq_cfi $__KERNEL_DS
 	pushq_cfi %rdx
 	pushfq_cfi
 	pushq_cfi $__KERNEL_CS
 	pushq_cfi $repeat_nmi
 	/* Put stack back */
 	addq $(11*8), %rsp
 	CFI_ADJUST_CFA_OFFSET -11*8
 nested_nmi_out:
 	popq_cfi %rdx
 	CFI_RESTORE rdx
 	/* No need to check faults here */
 	INTERRUPT_RETURN
 	CFI_RESTORE_STATE
 first_nmi:
 	/*
 	 * Because nested NMIs will use the pushed location that we
 	 * stored in rdx, we must keep that space available.
 	 * Here's what our stack frame will look like:
 	 * +-------------------------+
 	 * | original SS             |
 	 * | original Return RSP     |
 	 * | original RFLAGS         |
 	 * | original CS             |
 	 * | original RIP            |
 	 * +-------------------------+
 	 * | temp storage for rdx    |
 	 * +-------------------------+
 	 * | NMI executing variable  |
 	 * +-------------------------+
 	 * | Saved SS                |
 	 * | Saved Return RSP        |
 	 * | Saved RFLAGS            |
 	 * | Saved CS                |
 	 * | Saved RIP               |
 	 * +-------------------------+
 	 * | copied SS               |
 	 * | copied Return RSP       |
 	 * | copied RFLAGS           |
 	 * | copied CS               |
 	 * | copied RIP              |
 	 * +-------------------------+
 	 * | pt_regs                 |
 	 * +-------------------------+
 	 *
 	 * The saved stack frame is used to fix up the copied stack frame
 	 * that a nested NMI may change to make the interrupted NMI iret jump
 	 * to the repeat_nmi. The original stack frame and the temp storage
 	 * is also used by nested NMIs and can not be trusted on exit.
 	 */
 	/* Do not pop rdx, nested NMIs will corrupt that part of the stack */
 	movq (%rsp), %rdx
 	CFI_RESTORE rdx
 	/* Set the NMI executing variable on the stack. */
 	pushq_cfi $1
 	/* Copy the stack frame to the Saved frame */
 	.rept 5
 	pushq_cfi 6*8(%rsp)
 	.endr
 	CFI_DEF_CFA_OFFSET SS+8-RIP
 	/* Everything up to here is safe from nested NMIs */
 	/*
 	 * If there was a nested NMI, the first NMI's iret will return
 	 * here. But NMIs are still enabled and we can take another
 	 * nested NMI. The nested NMI checks the interrupted RIP to see
 	 * if it is between repeat_nmi and end_repeat_nmi, and if so
 	 * it will just return, as we are about to repeat an NMI anyway.
 	 * This makes it safe to copy to the stack frame that a nested
 	 * NMI will update.
 	 */
 repeat_nmi:
 	/*
 	 * Update the stack variable to say we are still in NMI (the update
 	 * is benign for the non-repeat case, where 1 was pushed just above
 	 * to this very stack slot).
 	 */
 	movq $1, 5*8(%rsp)
 	/* Make another copy, this one may be modified by nested NMIs */
 	.rept 5
 	pushq_cfi 4*8(%rsp)
 	.endr
 	CFI_DEF_CFA_OFFSET SS+8-RIP
 end_repeat_nmi:
 	/*
 	 * Everything below this point can be preempted by a nested
 	 * NMI if the first NMI took an exception and reset our iret stack
 	 * so that we repeat another NMI.
 	 */
 	pushq_cfi $-1		/* ORIG_RAX: no syscall to restart */
 	subq $ORIG_RAX-R15, %rsp
 	CFI_ADJUST_CFA_OFFSET ORIG_RAX-R15
 	/*
 	 * Use save_paranoid to handle SWAPGS, but no need to use paranoid_exit
 	 * as we should not be calling schedule in NMI context.
 	 * Even with normal interrupts enabled. An NMI should not be
 	 * setting NEED_RESCHED or anything that normal interrupts and
 	 * exceptions might do.
 	 */
 	call save_paranoid
 	DEFAULT_FRAME 0
 	/*
 	 * Save off the CR2 register. If we take a page fault in the NMI then
 	 * it could corrupt the CR2 value. If the NMI preempts a page fault
 	 * handler before it was able to read the CR2 register, and then the
 	 * NMI itself takes a page fault, the page fault that was preempted
 	 * will read the information from the NMI page fault and not the
 	 * origin fault. Save it off and restore it if it changes.
 	 * Use the r12 callee-saved register.
 	 */
 	movq %cr2, %r12
 	/* paranoidentry do_nmi, 0; without TRACE_IRQS_OFF */
 	movq %rsp,%rdi
 	movq $-1,%rsi
 	call do_nmi
 	/* Did the NMI take a page fault? Restore cr2 if it did */
 	movq %cr2, %rcx
 	cmpq %rcx, %r12
 	je 1f
 	movq %r12, %cr2
 1:
 	testl %ebx,%ebx				/* swapgs needed? */
 	jnz nmi_restore
 nmi_swapgs:
 	SWAPGS_UNSAFE_STACK
 nmi_restore:
 	RESTORE_ALL 8
 	/* Clear the NMI executing stack variable */
 	movq $0, 10*8(%rsp)
 	jmp irq_return
 	CFI_ENDPROC
 END(nmi)
 ENTRY(ignore_sysret)
 	CFI_STARTPROC
 	mov $-ENOSYS,%eax
 	sysret
 	CFI_ENDPROC
 END(ignore_sysret)
 /*
  * End of kprobes section
  */
 	.popsection

arch/x86/kernel/signal.c

Diff comments View file @ 9026843

 /*
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *  Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs
  *
  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  *  2000-06-20  Pentium III FXSR, SSE support by Gareth Hughes
  *  2000-2002   x86-64 support by Andi Kleen
  */
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/wait.h>
 #include <linux/tracehook.h>
 #include <linux/unistd.h>
 #include <linux/stddef.h>
 #include <linux/personality.h>
 #include <linux/uaccess.h>
 #include <linux/user-return-notifier.h>
 #include <linux/uprobes.h>
 #include <asm/processor.h>
 #include <asm/ucontext.h>
 #include <asm/i387.h>
 #include <asm/fpu-internal.h>
 #include <asm/vdso.h>
 #include <asm/mce.h>
 #include <asm/sighandling.h>
 #ifdef CONFIG_X86_64
 #include <asm/proto.h>
 #include <asm/ia32_unistd.h>
 #include <asm/sys_ia32.h>
 #endif /* CONFIG_X86_64 */
 #include <asm/syscall.h>
 #include <asm/syscalls.h>
 #include <asm/sigframe.h>
 #ifdef CONFIG_X86_32
 # define FIX_EFLAGS	(__FIX_EFLAGS | X86_EFLAGS_RF)
 #else
 # define FIX_EFLAGS	__FIX_EFLAGS
 #endif
 #define COPY(x)			do {			\
 	get_user_ex(regs->x, &sc->x);			\
 } while (0)
 #define GET_SEG(seg)		({			\
 	unsigned short tmp;				\
 	get_user_ex(tmp, &sc->seg);			\
 	tmp;						\
 })
 #define COPY_SEG(seg)		do {			\
 	regs->seg = GET_SEG(seg);			\
 } while (0)
 #define COPY_SEG_CPL3(seg)	do {			\
 	regs->seg = GET_SEG(seg) | 3;			\
 } while (0)
 int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
 		       unsigned long *pax)
 {
 	void __user *buf;
 	unsigned int tmpflags;
 	unsigned int err = 0;
 	/* Always make any pending restarted system calls return -EINTR */
 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
 	get_user_try {
 #ifdef CONFIG_X86_32
 		set_user_gs(regs, GET_SEG(gs));
 		COPY_SEG(fs);
 		COPY_SEG(es);
 		COPY_SEG(ds);
 #endif /* CONFIG_X86_32 */
 		COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 		COPY(dx); COPY(cx); COPY(ip);
 #ifdef CONFIG_X86_64
 		COPY(r8);
 		COPY(r9);
 		COPY(r10);
 		COPY(r11);
 		COPY(r12);
 		COPY(r13);
 		COPY(r14);
 		COPY(r15);
 #endif /* CONFIG_X86_64 */
 #ifdef CONFIG_X86_32
 		COPY_SEG_CPL3(cs);
 		COPY_SEG_CPL3(ss);
 #else /* !CONFIG_X86_32 */
 		/* Kernel saves and restores only the CS segment register on signals,
 		 * which is the bare minimum needed to allow mixed 32/64-bit code.
 		 * App's signal handler can save/restore other segments if needed. */
 		COPY_SEG_CPL3(cs);
 #endif /* CONFIG_X86_32 */
 		get_user_ex(tmpflags, &sc->flags);
 		regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
 		regs->orig_ax = -1;		/* disable syscall checks */
 		get_user_ex(buf, &sc->fpstate);
 		get_user_ex(*pax, &sc->ax);
 	} get_user_catch(err);
 	err |= restore_xstate_sig(buf, config_enabled(CONFIG_X86_32));
 	return err;
 }
 int setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate,
 		     struct pt_regs *regs, unsigned long mask)
 {
 	int err = 0;
 	put_user_try {
 #ifdef CONFIG_X86_32
 		put_user_ex(get_user_gs(regs), (unsigned int __user *)&sc->gs);
 		put_user_ex(regs->fs, (unsigned int __user *)&sc->fs);
 		put_user_ex(regs->es, (unsigned int __user *)&sc->es);
 		put_user_ex(regs->ds, (unsigned int __user *)&sc->ds);
 #endif /* CONFIG_X86_32 */
 		put_user_ex(regs->di, &sc->di);
 		put_user_ex(regs->si, &sc->si);
 		put_user_ex(regs->bp, &sc->bp);
 		put_user_ex(regs->sp, &sc->sp);
 		put_user_ex(regs->bx, &sc->bx);
 		put_user_ex(regs->dx, &sc->dx);
 		put_user_ex(regs->cx, &sc->cx);
 		put_user_ex(regs->ax, &sc->ax);
 #ifdef CONFIG_X86_64
 		put_user_ex(regs->r8, &sc->r8);
 		put_user_ex(regs->r9, &sc->r9);
 		put_user_ex(regs->r10, &sc->r10);
 		put_user_ex(regs->r11, &sc->r11);
 		put_user_ex(regs->r12, &sc->r12);
 		put_user_ex(regs->r13, &sc->r13);
 		put_user_ex(regs->r14, &sc->r14);
 		put_user_ex(regs->r15, &sc->r15);
 #endif /* CONFIG_X86_64 */
 		put_user_ex(current->thread.trap_nr, &sc->trapno);
 		put_user_ex(current->thread.error_code, &sc->err);
 		put_user_ex(regs->ip, &sc->ip);
 #ifdef CONFIG_X86_32
 		put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
 		put_user_ex(regs->flags, &sc->flags);
 		put_user_ex(regs->sp, &sc->sp_at_signal);
 		put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
 #else /* !CONFIG_X86_32 */
 		put_user_ex(regs->flags, &sc->flags);
 		put_user_ex(regs->cs, &sc->cs);
 		put_user_ex(0, &sc->gs);
 		put_user_ex(0, &sc->fs);
 #endif /* CONFIG_X86_32 */
 		put_user_ex(fpstate, &sc->fpstate);
 		/* non-iBCS2 extensions.. */
 		put_user_ex(mask, &sc->oldmask);
 		put_user_ex(current->thread.cr2, &sc->cr2);
 	} put_user_catch(err);
 	return err;
 }
 /*
  * Set up a signal frame.
  */
 /*
  * Determine which stack to use..
  */
 static unsigned long align_sigframe(unsigned long sp)
 {
 #ifdef CONFIG_X86_32
 	/*
 	 * Align the stack pointer according to the i386 ABI,
 	 * i.e. so that on function entry ((sp + 4) & 15) == 0.
 	 */
 	sp = ((sp + 4) & -16ul) - 4;
 #else /* !CONFIG_X86_32 */
 	sp = round_down(sp, 16) - 8;
 #endif
 	return sp;
 }
 static inline void __user *
 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size,
 	     void __user **fpstate)
 {
 	/* Default to using normal stack */
 	unsigned long math_size = 0;
 	unsigned long sp = regs->sp;
 	unsigned long buf_fx = 0;
 	int onsigstack = on_sig_stack(sp);
 	/* redzone */
 	if (config_enabled(CONFIG_X86_64))
 		sp -= 128;
 	if (!onsigstack) {
 		/* This is the X/Open sanctioned signal stack switching.  */
 		if (ka->sa.sa_flags & SA_ONSTACK) {
 			if (current->sas_ss_size)
 				sp = current->sas_ss_sp + current->sas_ss_size;
 		} else if (config_enabled(CONFIG_X86_32) &&
 			   (regs->ss & 0xffff) != __USER_DS &&
 			   !(ka->sa.sa_flags & SA_RESTORER) &&
 			   ka->sa.sa_restorer) {
 				/* This is the legacy signal stack switching. */
 				sp = (unsigned long) ka->sa.sa_restorer;
 		}
 	}
 	if (used_math()) {
 		sp = alloc_mathframe(sp, config_enabled(CONFIG_X86_32),
 				     &buf_fx, &math_size);
 		*fpstate = (void __user *)sp;
 	}
 	sp = align_sigframe(sp - frame_size);
 	/*
 	 * If we are on the alternate signal stack and would overflow it, don't.
 	 * Return an always-bogus address instead so we will die with SIGSEGV.
 	 */
 	if (onsigstack && !likely(on_sig_stack(sp)))
 		return (void __user *)-1L;
 	/* save i387 and extended state */
 	if (used_math() &&
 	    save_xstate_sig(*fpstate, (void __user *)buf_fx, math_size) < 0)
 		return (void __user *)-1L;
 	return (void __user *)sp;
 }
 #ifdef CONFIG_X86_32
 static const struct {
 	u16 poplmovl;
 	u32 val;
 	u16 int80;
 } __attribute__((packed)) retcode = {
 	0xb858,		/* popl %eax; movl $..., %eax */
 	__NR_sigreturn,
 	0x80cd,		/* int $0x80 */
 };
 static const struct {
 	u8  movl;
 	u32 val;
 	u16 int80;
 	u8  pad;
 } __attribute__((packed)) rt_retcode = {
 	0xb8,		/* movl $..., %eax */
 	__NR_rt_sigreturn,
 	0x80cd,		/* int $0x80 */
 	0
 };
 static int
 __setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
 	      struct pt_regs *regs)
 {
 	struct sigframe __user *frame;
 	void __user *restorer;
 	int err = 0;
 	void __user *fpstate = NULL;
 	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		return -EFAULT;
 	if (__put_user(sig, &frame->sig))
 		return -EFAULT;
 	if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
 		return -EFAULT;
 	if (_NSIG_WORDS > 1) {
 		if (__copy_to_user(&frame->extramask, &set->sig[1],
 				   sizeof(frame->extramask)))
 			return -EFAULT;
 	}
 	if (current->mm->context.vdso)
 		restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn);
 	else
 		restorer = &frame->retcode;
 	if (ka->sa.sa_flags & SA_RESTORER)
 		restorer = ka->sa.sa_restorer;
 	/* Set up to return from userspace.  */
 	err |= __put_user(restorer, &frame->pretcode);
 	/*
 	 * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80
 	 *
 	 * WE DO NOT USE IT ANY MORE! It's only left here for historical
 	 * reasons and because gdb uses it as a signature to notice
 	 * signal handler stack frames.
 	 */
 	err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode);
 	if (err)
 		return -EFAULT;
 	/* Set up registers for signal handler */
 	regs->sp = (unsigned long)frame;
 	regs->ip = (unsigned long)ka->sa.sa_handler;
 	regs->ax = (unsigned long)sig;
 	regs->dx = 0;
 	regs->cx = 0;
 	regs->ds = __USER_DS;
 	regs->es = __USER_DS;
 	regs->ss = __USER_DS;
 	regs->cs = __USER_CS;
 	return 0;
 }
 static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 			    sigset_t *set, struct pt_regs *regs)
 {
 	struct rt_sigframe __user *frame;
 	void __user *restorer;
 	int err = 0;
 	void __user *fpstate = NULL;
 	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		return -EFAULT;
 	put_user_try {
 		put_user_ex(sig, &frame->sig);
 		put_user_ex(&frame->info, &frame->pinfo);
 		put_user_ex(&frame->uc, &frame->puc);
 		/* Create the ucontext.  */
 		if (cpu_has_xsave)
 			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 		else
 			put_user_ex(0, &frame->uc.uc_flags);
 		put_user_ex(0, &frame->uc.uc_link);
 		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 		put_user_ex(sas_ss_flags(regs->sp),
 			    &frame->uc.uc_stack.ss_flags);
 		put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 		/* Set up to return from userspace.  */
 		restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn);
 		if (ka->sa.sa_flags & SA_RESTORER)
 			restorer = ka->sa.sa_restorer;
 		put_user_ex(restorer, &frame->pretcode);
 		/*
 		 * This is movl $__NR_rt_sigreturn, %ax ; int $0x80
 		 *
 		 * WE DO NOT USE IT ANY MORE! It's only left here for historical
 		 * reasons and because gdb uses it as a signature to notice
 		 * signal handler stack frames.
 		 */
 		put_user_ex(*((u64 *)&rt_retcode), (u64 *)frame->retcode);
 	} put_user_catch(err);
 	err |= copy_siginfo_to_user(&frame->info, info);
 	err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 				regs, set->sig[0]);
 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 	if (err)
 		return -EFAULT;
 	/* Set up registers for signal handler */
 	regs->sp = (unsigned long)frame;
 	regs->ip = (unsigned long)ka->sa.sa_handler;
 	regs->ax = (unsigned long)sig;
 	regs->dx = (unsigned long)&frame->info;
 	regs->cx = (unsigned long)&frame->uc;
 	regs->ds = __USER_DS;
 	regs->es = __USER_DS;
 	regs->ss = __USER_DS;
 	regs->cs = __USER_CS;
 	return 0;
 }
 #else /* !CONFIG_X86_32 */
 static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 			    sigset_t *set, struct pt_regs *regs)
 {
 	struct rt_sigframe __user *frame;
 	void __user *fp = NULL;
 	int err = 0;
 	struct task_struct *me = current;
 	frame = get_sigframe(ka, regs, sizeof(struct rt_sigframe), &fp);
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		return -EFAULT;
 	if (ka->sa.sa_flags & SA_SIGINFO) {
 		if (copy_siginfo_to_user(&frame->info, info))
 			return -EFAULT;
 	}
 	put_user_try {
 		/* Create the ucontext.  */
 		if (cpu_has_xsave)
 			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 		else
 			put_user_ex(0, &frame->uc.uc_flags);
 		put_user_ex(0, &frame->uc.uc_link);
 		put_user_ex(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 		put_user_ex(sas_ss_flags(regs->sp),
 			    &frame->uc.uc_stack.ss_flags);
 		put_user_ex(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
 		/* Set up to return from userspace.  If provided, use a stub
 		   already in userspace.  */
 		/* x86-64 should always use SA_RESTORER. */
 		if (ka->sa.sa_flags & SA_RESTORER) {
 			put_user_ex(ka->sa.sa_restorer, &frame->pretcode);
 		} else {
 			/* could use a vstub here */
 			err |= -EFAULT;
 		}
 	} put_user_catch(err);
 	err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]);
 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 	if (err)
 		return -EFAULT;
 	/* Set up registers for signal handler */
 	regs->di = sig;
 	/* In case the signal handler was declared without prototypes */
 	regs->ax = 0;
 	/* This also works for non SA_SIGINFO handlers because they expect the
 	   next argument after the signal number on the stack. */
 	regs->si = (unsigned long)&frame->info;
 	regs->dx = (unsigned long)&frame->uc;
 	regs->ip = (unsigned long) ka->sa.sa_handler;
 	regs->sp = (unsigned long)frame;
 	/* Set up the CS register to run signal handlers in 64-bit mode,
 	   even if the handler happens to be interrupting 32-bit code. */
 	regs->cs = __USER_CS;
 	return 0;
 }
 #endif /* CONFIG_X86_32 */
 static int x32_setup_rt_frame(int sig, struct k_sigaction *ka,
 			      siginfo_t *info, compat_sigset_t *set,
 			      struct pt_regs *regs)
 {
 #ifdef CONFIG_X86_X32_ABI
 	struct rt_sigframe_x32 __user *frame;
 	void __user *restorer;
 	int err = 0;
 	void __user *fpstate = NULL;
 	frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate);
 	if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 		return -EFAULT;
 	if (ka->sa.sa_flags & SA_SIGINFO) {
 		if (copy_siginfo_to_user32(&frame->info, info))
 			return -EFAULT;
 	}
 	put_user_try {
 		/* Create the ucontext.  */
 		if (cpu_has_xsave)
 			put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
 		else
 			put_user_ex(0, &frame->uc.uc_flags);
 		put_user_ex(0, &frame->uc.uc_link);
 		put_user_ex(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 		put_user_ex(sas_ss_flags(regs->sp),
 			    &frame->uc.uc_stack.ss_flags);
 		put_user_ex(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 		put_user_ex(0, &frame->uc.uc__pad0);
 		if (ka->sa.sa_flags & SA_RESTORER) {
 			restorer = ka->sa.sa_restorer;
 		} else {
 			/* could use a vstub here */
 			restorer = NULL;
 			err |= -EFAULT;
 		}
 		put_user_ex(restorer, &frame->pretcode);
 	} put_user_catch(err);
 	err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
 				regs, set->sig[0]);
 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 	if (err)
 		return -EFAULT;
 	/* Set up registers for signal handler */
 	regs->sp = (unsigned long) frame;
 	regs->ip = (unsigned long) ka->sa.sa_handler;
 	/* We use the x32 calling convention here... */
 	regs->di = sig;
 	regs->si = (unsigned long) &frame->info;
 	regs->dx = (unsigned long) &frame->uc;
 	loadsegment(ds, __USER_DS);
 	loadsegment(es, __USER_DS);
 	regs->cs = __USER_CS;
 	regs->ss = __USER_DS;
 #endif	/* CONFIG_X86_X32_ABI */
 	return 0;
 }
 #ifdef CONFIG_X86_32
 /*
  * Atomically swap in the new signal mask, and wait for a signal.
  */
 asmlinkage int
 sys_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
 	sigset_t blocked;
 	siginitset(&blocked, mask);
 	return sigsuspend(&blocked);
 }
 asmlinkage int
 sys_sigaction(int sig, const struct old_sigaction __user *act,
 	      struct old_sigaction __user *oact)
 {
 	struct k_sigaction new_ka, old_ka;
 	int ret = 0;
 	if (act) {
 		old_sigset_t mask;
 		if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 			return -EFAULT;
 		get_user_try {
 			get_user_ex(new_ka.sa.sa_handler, &act->sa_handler);
 			get_user_ex(new_ka.sa.sa_flags, &act->sa_flags);
 			get_user_ex(mask, &act->sa_mask);
 			get_user_ex(new_ka.sa.sa_restorer, &act->sa_restorer);
 		} get_user_catch(ret);
 		if (ret)
 			return -EFAULT;
 		siginitset(&new_ka.sa.sa_mask, mask);
 	}
 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 	if (!ret && oact) {
 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 			return -EFAULT;
 		put_user_try {
 			put_user_ex(old_ka.sa.sa_handler, &oact->sa_handler);
 			put_user_ex(old_ka.sa.sa_flags, &oact->sa_flags);
 			put_user_ex(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 			put_user_ex(old_ka.sa.sa_restorer, &oact->sa_restorer);
 		} put_user_catch(ret);
 		if (ret)
 			return -EFAULT;
 	}
 	return ret;
 }
 #endif /* CONFIG_X86_32 */
 /*
  * Do a signal return; undo the signal stack.
  */
 #ifdef CONFIG_X86_32
 unsigned long sys_sigreturn(struct pt_regs *regs)
 {
 	struct sigframe __user *frame;
 	unsigned long ax;
 	sigset_t set;
 	frame = (struct sigframe __user *)(regs->sp - 8);
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1
 		&& __copy_from_user(&set.sig[1], &frame->extramask,
 				    sizeof(frame->extramask))))
 		goto badframe;
 	set_current_blocked(&set);
 	if (restore_sigcontext(regs, &frame->sc, &ax))
 		goto badframe;
 	return ax;
 badframe:
 	signal_fault(regs, frame, "sigreturn");
 	return 0;
 }
 #endif /* CONFIG_X86_32 */
 long sys_rt_sigreturn(struct pt_regs *regs)
 {
 	struct rt_sigframe __user *frame;
 	unsigned long ax;
 	sigset_t set;
 	frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long));
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 		goto badframe;
 	set_current_blocked(&set);
 	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 		goto badframe;
 	if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT)
 		goto badframe;
 	return ax;
 badframe:
 	signal_fault(regs, frame, "rt_sigreturn");
 	return 0;
 }
 /*
  * OK, we're invoking a handler:
  */
 static int signr_convert(int sig)
 {
 #ifdef CONFIG_X86_32
 	struct thread_info *info = current_thread_info();
 	if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32)
 		return info->exec_domain->signal_invmap[sig];
 #endif /* CONFIG_X86_32 */
 	return sig;
 }
 static int
 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 		struct pt_regs *regs)
 {
 	int usig = signr_convert(sig);
 	sigset_t *set = sigmask_to_save();
 	compat_sigset_t *cset = (compat_sigset_t *) set;
 	/* Set up the stack frame */
 	if (is_ia32_frame()) {
 		if (ka->sa.sa_flags & SA_SIGINFO)
 			return ia32_setup_rt_frame(usig, ka, info, cset, regs);
 		else
 			return ia32_setup_frame(usig, ka, cset, regs);
 	} else if (is_x32_frame()) {
 		return x32_setup_rt_frame(usig, ka, info, cset, regs);
 	} else {
 		return __setup_rt_frame(sig, ka, info, set, regs);
 	}
 }
 static void
 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
 		struct pt_regs *regs)
 {
 	/* 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;
 	if (setup_rt_frame(sig, ka, info, regs) < 0) {
 		force_sigsegv(sig, current);
 		return;
 	}
 	/*
 	 * 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;
 	signal_delivered(sig, info, ka, regs,
 			 test_thread_flag(TIF_SINGLESTEP));
 }
 #ifdef CONFIG_X86_32
 #define NR_restart_syscall	__NR_restart_syscall
 #else /* !CONFIG_X86_32 */
 #define NR_restart_syscall	\
 	test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall
 #endif /* CONFIG_X86_32 */
 /*
  * 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)
 {
 	struct k_sigaction ka;
 	siginfo_t info;
 	int signr;
 	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 	if (signr > 0) {
 		/* Whee! Actually deliver the signal.  */
 		handle_signal(signr, &info, &ka, regs);
 		return;
 	}
 	/* Did we come from a system call? */
 	if (syscall_get_nr(current, regs) >= 0) {
 		/* Restart the system call - no handlers present */
 		switch (syscall_get_error(current, regs)) {
 		case -ERESTARTNOHAND:
 		case -ERESTARTSYS:
 		case -ERESTARTNOINTR:
 			regs->ax = regs->orig_ax;
 			regs->ip -= 2;
 			break;
 		case -ERESTART_RESTARTBLOCK:
 			regs->ax = NR_restart_syscall;
 			regs->ip -= 2;
 			break;
 		}
 	}
 	/*
 	 * If there's no signal to deliver, we just put the saved sigmask
 	 * back.
 	 */
 	restore_saved_sigmask();
 }
 /*
  * notification of userspace execution resumption
  * - triggered by the TIF_WORK_MASK flags
  */
 void
 do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
 {
 	rcu_user_exit();
 #ifdef CONFIG_X86_MCE
 	/* notify userspace of pending MCEs */
 	if (thread_info_flags & _TIF_MCE_NOTIFY)
 		mce_notify_process();
 #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */
 	if (thread_info_flags & _TIF_UPROBE)
 		uprobe_notify_resume(regs);
 	/* deal with pending signal delivery */
 	if (thread_info_flags & _TIF_SIGPENDING)
 		do_signal(regs);
 	if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 		clear_thread_flag(TIF_NOTIFY_RESUME);
 		tracehook_notify_resume(regs);
 	}
 	if (thread_info_flags & _TIF_USER_RETURN_NOTIFY)
 		fire_user_return_notifiers();
 	rcu_user_enter();
 }
 void signal_fault(struct pt_regs *regs, void __user *frame, char *where)
 {
 	struct task_struct *me = current;
 	if (show_unhandled_signals && printk_ratelimit()) {
 		printk("%s"
 		       "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx",
 		       task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG,
 		       me->comm, me->pid, where, frame,
 		       regs->ip, regs->sp, regs->orig_ax);
 		print_vma_addr(" in ", regs->ip);
 		pr_cont("\n");
 	}
 	force_sig(SIGSEGV, me);
 }
 #ifdef CONFIG_X86_X32_ABI
 asmlinkage long sys32_x32_rt_sigreturn(struct pt_regs *regs)
 {
 	struct rt_sigframe_x32 __user *frame;
 	sigset_t set;
 	unsigned long ax;
-	struct pt_regs tregs;
 	frame = (struct rt_sigframe_x32 __user *)(regs->sp - 8);
 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 		goto badframe;
 	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 		goto badframe;
 	set_current_blocked(&set);
 	if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
 		goto badframe;
-	tregs = *regs;
+	if (compat_restore_altstack(&frame->uc.uc_stack))
-	if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 		goto badframe;
 	return ax;
 badframe:
 	signal_fault(regs, frame, "x32 rt_sigreturn");
 	return 0;
 }
 #endif

arch/x86/syscalls/syscall_32.tbl

Diff comments View file @ 9026843

arch/x86/syscalls/syscall_64.tbl

Diff comments View file @ 9026843

1	#	1	#
2	# 64-bit system call numbers and entry vectors	2	# 64-bit system call numbers and entry vectors
3	#	3	#
4	# The format is:	4	# The format is:
5	# <number> <abi> <name> <entry point>	5	# <number> <abi> <name> <entry point>
6	#	6	#
7	# The abi is "common", "64" or "x32" for this file.	7	# The abi is "common", "64" or "x32" for this file.
8	#	8	#
9	0 common read sys_read	9	0 common read sys_read
10	1 common write sys_write	10	1 common write sys_write
11	2 common open sys_open	11	2 common open sys_open
12	3 common close sys_close	12	3 common close sys_close
13	4 common stat sys_newstat	13	4 common stat sys_newstat
14	5 common fstat sys_newfstat	14	5 common fstat sys_newfstat
15	6 common lstat sys_newlstat	15	6 common lstat sys_newlstat
16	7 common poll sys_poll	16	7 common poll sys_poll
17	8 common lseek sys_lseek	17	8 common lseek sys_lseek
18	9 common mmap sys_mmap	18	9 common mmap sys_mmap
19	10 common mprotect sys_mprotect	19	10 common mprotect sys_mprotect
20	11 common munmap sys_munmap	20	11 common munmap sys_munmap
21	12 common brk sys_brk	21	12 common brk sys_brk
22	13 64 rt_sigaction sys_rt_sigaction	22	13 64 rt_sigaction sys_rt_sigaction
23	14 common rt_sigprocmask sys_rt_sigprocmask	23	14 common rt_sigprocmask sys_rt_sigprocmask
24	15 64 rt_sigreturn stub_rt_sigreturn	24	15 64 rt_sigreturn stub_rt_sigreturn
25	16 64 ioctl sys_ioctl	25	16 64 ioctl sys_ioctl
26	17 common pread64 sys_pread64	26	17 common pread64 sys_pread64
27	18 common pwrite64 sys_pwrite64	27	18 common pwrite64 sys_pwrite64
28	19 64 readv sys_readv	28	19 64 readv sys_readv
29	20 64 writev sys_writev	29	20 64 writev sys_writev
30	21 common access sys_access	30	21 common access sys_access
31	22 common pipe sys_pipe	31	22 common pipe sys_pipe
32	23 common select sys_select	32	23 common select sys_select
33	24 common sched_yield sys_sched_yield	33	24 common sched_yield sys_sched_yield
34	25 common mremap sys_mremap	34	25 common mremap sys_mremap
35	26 common msync sys_msync	35	26 common msync sys_msync
36	27 common mincore sys_mincore	36	27 common mincore sys_mincore
37	28 common madvise sys_madvise	37	28 common madvise sys_madvise
38	29 common shmget sys_shmget	38	29 common shmget sys_shmget
39	30 common shmat sys_shmat	39	30 common shmat sys_shmat
40	31 common shmctl sys_shmctl	40	31 common shmctl sys_shmctl
41	32 common dup sys_dup	41	32 common dup sys_dup
42	33 common dup2 sys_dup2	42	33 common dup2 sys_dup2
43	34 common pause sys_pause	43	34 common pause sys_pause
44	35 common nanosleep sys_nanosleep	44	35 common nanosleep sys_nanosleep
45	36 common getitimer sys_getitimer	45	36 common getitimer sys_getitimer
46	37 common alarm sys_alarm	46	37 common alarm sys_alarm
47	38 common setitimer sys_setitimer	47	38 common setitimer sys_setitimer
48	39 common getpid sys_getpid	48	39 common getpid sys_getpid
49	40 common sendfile sys_sendfile64	49	40 common sendfile sys_sendfile64
50	41 common socket sys_socket	50	41 common socket sys_socket
51	42 common connect sys_connect	51	42 common connect sys_connect
52	43 common accept sys_accept	52	43 common accept sys_accept
53	44 common sendto sys_sendto	53	44 common sendto sys_sendto
54	45 64 recvfrom sys_recvfrom	54	45 64 recvfrom sys_recvfrom
55	46 64 sendmsg sys_sendmsg	55	46 64 sendmsg sys_sendmsg
56	47 64 recvmsg sys_recvmsg	56	47 64 recvmsg sys_recvmsg
57	48 common shutdown sys_shutdown	57	48 common shutdown sys_shutdown
58	49 common bind sys_bind	58	49 common bind sys_bind
59	50 common listen sys_listen	59	50 common listen sys_listen
60	51 common getsockname sys_getsockname	60	51 common getsockname sys_getsockname
61	52 common getpeername sys_getpeername	61	52 common getpeername sys_getpeername
62	53 common socketpair sys_socketpair	62	53 common socketpair sys_socketpair
63	54 64 setsockopt sys_setsockopt	63	54 64 setsockopt sys_setsockopt
64	55 64 getsockopt sys_getsockopt	64	55 64 getsockopt sys_getsockopt
65	56 common clone stub_clone	65	56 common clone stub_clone
66	57 common fork stub_fork	66	57 common fork stub_fork
67	58 common vfork stub_vfork	67	58 common vfork stub_vfork
68	59 64 execve stub_execve	68	59 64 execve stub_execve
69	60 common exit sys_exit	69	60 common exit sys_exit
70	61 common wait4 sys_wait4	70	61 common wait4 sys_wait4
71	62 common kill sys_kill	71	62 common kill sys_kill
72	63 common uname sys_newuname	72	63 common uname sys_newuname
73	64 common semget sys_semget	73	64 common semget sys_semget
74	65 common semop sys_semop	74	65 common semop sys_semop
75	66 common semctl sys_semctl	75	66 common semctl sys_semctl
76	67 common shmdt sys_shmdt	76	67 common shmdt sys_shmdt
77	68 common msgget sys_msgget	77	68 common msgget sys_msgget
78	69 common msgsnd sys_msgsnd	78	69 common msgsnd sys_msgsnd
79	70 common msgrcv sys_msgrcv	79	70 common msgrcv sys_msgrcv
80	71 common msgctl sys_msgctl	80	71 common msgctl sys_msgctl
81	72 common fcntl sys_fcntl	81	72 common fcntl sys_fcntl
82	73 common flock sys_flock	82	73 common flock sys_flock
83	74 common fsync sys_fsync	83	74 common fsync sys_fsync
84	75 common fdatasync sys_fdatasync	84	75 common fdatasync sys_fdatasync
85	76 common truncate sys_truncate	85	76 common truncate sys_truncate
86	77 common ftruncate sys_ftruncate	86	77 common ftruncate sys_ftruncate
87	78 common getdents sys_getdents	87	78 common getdents sys_getdents
88	79 common getcwd sys_getcwd	88	79 common getcwd sys_getcwd
89	80 common chdir sys_chdir	89	80 common chdir sys_chdir
90	81 common fchdir sys_fchdir	90	81 common fchdir sys_fchdir
91	82 common rename sys_rename	91	82 common rename sys_rename
92	83 common mkdir sys_mkdir	92	83 common mkdir sys_mkdir
93	84 common rmdir sys_rmdir	93	84 common rmdir sys_rmdir
94	85 common creat sys_creat	94	85 common creat sys_creat
95	86 common link sys_link	95	86 common link sys_link
96	87 common unlink sys_unlink	96	87 common unlink sys_unlink
97	88 common symlink sys_symlink	97	88 common symlink sys_symlink
98	89 common readlink sys_readlink	98	89 common readlink sys_readlink
99	90 common chmod sys_chmod	99	90 common chmod sys_chmod
100	91 common fchmod sys_fchmod	100	91 common fchmod sys_fchmod
101	92 common chown sys_chown	101	92 common chown sys_chown
102	93 common fchown sys_fchown	102	93 common fchown sys_fchown
103	94 common lchown sys_lchown	103	94 common lchown sys_lchown
104	95 common umask sys_umask	104	95 common umask sys_umask
105	96 common gettimeofday sys_gettimeofday	105	96 common gettimeofday sys_gettimeofday
106	97 common getrlimit sys_getrlimit	106	97 common getrlimit sys_getrlimit
107	98 common getrusage sys_getrusage	107	98 common getrusage sys_getrusage
108	99 common sysinfo sys_sysinfo	108	99 common sysinfo sys_sysinfo
109	100 common times sys_times	109	100 common times sys_times
110	101 64 ptrace sys_ptrace	110	101 64 ptrace sys_ptrace
111	102 common getuid sys_getuid	111	102 common getuid sys_getuid
112	103 common syslog sys_syslog	112	103 common syslog sys_syslog
113	104 common getgid sys_getgid	113	104 common getgid sys_getgid
114	105 common setuid sys_setuid	114	105 common setuid sys_setuid
115	106 common setgid sys_setgid	115	106 common setgid sys_setgid
116	107 common geteuid sys_geteuid	116	107 common geteuid sys_geteuid
117	108 common getegid sys_getegid	117	108 common getegid sys_getegid
118	109 common setpgid sys_setpgid	118	109 common setpgid sys_setpgid
119	110 common getppid sys_getppid	119	110 common getppid sys_getppid
120	111 common getpgrp sys_getpgrp	120	111 common getpgrp sys_getpgrp
121	112 common setsid sys_setsid	121	112 common setsid sys_setsid
122	113 common setreuid sys_setreuid	122	113 common setreuid sys_setreuid
123	114 common setregid sys_setregid	123	114 common setregid sys_setregid
124	115 common getgroups sys_getgroups	124	115 common getgroups sys_getgroups
125	116 common setgroups sys_setgroups	125	116 common setgroups sys_setgroups
126	117 common setresuid sys_setresuid	126	117 common setresuid sys_setresuid
127	118 common getresuid sys_getresuid	127	118 common getresuid sys_getresuid
128	119 common setresgid sys_setresgid	128	119 common setresgid sys_setresgid
129	120 common getresgid sys_getresgid	129	120 common getresgid sys_getresgid
130	121 common getpgid sys_getpgid	130	121 common getpgid sys_getpgid
131	122 common setfsuid sys_setfsuid	131	122 common setfsuid sys_setfsuid
132	123 common setfsgid sys_setfsgid	132	123 common setfsgid sys_setfsgid
133	124 common getsid sys_getsid	133	124 common getsid sys_getsid
134	125 common capget sys_capget	134	125 common capget sys_capget
135	126 common capset sys_capset	135	126 common capset sys_capset
136	127 64 rt_sigpending sys_rt_sigpending	136	127 64 rt_sigpending sys_rt_sigpending
137	128 64 rt_sigtimedwait sys_rt_sigtimedwait	137	128 64 rt_sigtimedwait sys_rt_sigtimedwait
138	129 64 rt_sigqueueinfo sys_rt_sigqueueinfo	138	129 64 rt_sigqueueinfo sys_rt_sigqueueinfo
139	130 common rt_sigsuspend sys_rt_sigsuspend	139	130 common rt_sigsuspend sys_rt_sigsuspend
140	131 64 sigaltstack sys_sigaltstack	140	131 64 sigaltstack sys_sigaltstack
141	132 common utime sys_utime	141	132 common utime sys_utime
142	133 common mknod sys_mknod	142	133 common mknod sys_mknod
143	134 64 uselib	143	134 64 uselib
144	135 common personality sys_personality	144	135 common personality sys_personality
145	136 common ustat sys_ustat	145	136 common ustat sys_ustat
146	137 common statfs sys_statfs	146	137 common statfs sys_statfs
147	138 common fstatfs sys_fstatfs	147	138 common fstatfs sys_fstatfs
148	139 common sysfs sys_sysfs	148	139 common sysfs sys_sysfs
149	140 common getpriority sys_getpriority	149	140 common getpriority sys_getpriority
150	141 common setpriority sys_setpriority	150	141 common setpriority sys_setpriority
151	142 common sched_setparam sys_sched_setparam	151	142 common sched_setparam sys_sched_setparam
152	143 common sched_getparam sys_sched_getparam	152	143 common sched_getparam sys_sched_getparam
153	144 common sched_setscheduler sys_sched_setscheduler	153	144 common sched_setscheduler sys_sched_setscheduler
154	145 common sched_getscheduler sys_sched_getscheduler	154	145 common sched_getscheduler sys_sched_getscheduler
155	146 common sched_get_priority_max sys_sched_get_priority_max	155	146 common sched_get_priority_max sys_sched_get_priority_max
156	147 common sched_get_priority_min sys_sched_get_priority_min	156	147 common sched_get_priority_min sys_sched_get_priority_min
157	148 common sched_rr_get_interval sys_sched_rr_get_interval	157	148 common sched_rr_get_interval sys_sched_rr_get_interval
158	149 common mlock sys_mlock	158	149 common mlock sys_mlock
159	150 common munlock sys_munlock	159	150 common munlock sys_munlock
160	151 common mlockall sys_mlockall	160	151 common mlockall sys_mlockall
161	152 common munlockall sys_munlockall	161	152 common munlockall sys_munlockall
162	153 common vhangup sys_vhangup	162	153 common vhangup sys_vhangup
163	154 common modify_ldt sys_modify_ldt	163	154 common modify_ldt sys_modify_ldt
164	155 common pivot_root sys_pivot_root	164	155 common pivot_root sys_pivot_root
165	156 64 _sysctl sys_sysctl	165	156 64 _sysctl sys_sysctl
166	157 common prctl sys_prctl	166	157 common prctl sys_prctl
167	158 common arch_prctl sys_arch_prctl	167	158 common arch_prctl sys_arch_prctl
168	159 common adjtimex sys_adjtimex	168	159 common adjtimex sys_adjtimex
169	160 common setrlimit sys_setrlimit	169	160 common setrlimit sys_setrlimit
170	161 common chroot sys_chroot	170	161 common chroot sys_chroot
171	162 common sync sys_sync	171	162 common sync sys_sync
172	163 common acct sys_acct	172	163 common acct sys_acct
173	164 common settimeofday sys_settimeofday	173	164 common settimeofday sys_settimeofday
174	165 common mount sys_mount	174	165 common mount sys_mount
175	166 common umount2 sys_umount	175	166 common umount2 sys_umount
176	167 common swapon sys_swapon	176	167 common swapon sys_swapon
177	168 common swapoff sys_swapoff	177	168 common swapoff sys_swapoff
178	169 common reboot sys_reboot	178	169 common reboot sys_reboot
179	170 common sethostname sys_sethostname	179	170 common sethostname sys_sethostname
180	171 common setdomainname sys_setdomainname	180	171 common setdomainname sys_setdomainname
181	172 common iopl stub_iopl	181	172 common iopl stub_iopl
182	173 common ioperm sys_ioperm	182	173 common ioperm sys_ioperm
183	174 64 create_module	183	174 64 create_module
184	175 common init_module sys_init_module	184	175 common init_module sys_init_module
185	176 common delete_module sys_delete_module	185	176 common delete_module sys_delete_module
186	177 64 get_kernel_syms	186	177 64 get_kernel_syms
187	178 64 query_module	187	178 64 query_module
188	179 common quotactl sys_quotactl	188	179 common quotactl sys_quotactl
189	180 64 nfsservctl	189	180 64 nfsservctl
190	181 common getpmsg	190	181 common getpmsg
191	182 common putpmsg	191	182 common putpmsg
192	183 common afs_syscall	192	183 common afs_syscall
193	184 common tuxcall	193	184 common tuxcall
194	185 common security	194	185 common security
195	186 common gettid sys_gettid	195	186 common gettid sys_gettid
196	187 common readahead sys_readahead	196	187 common readahead sys_readahead
197	188 common setxattr sys_setxattr	197	188 common setxattr sys_setxattr
198	189 common lsetxattr sys_lsetxattr	198	189 common lsetxattr sys_lsetxattr
199	190 common fsetxattr sys_fsetxattr	199	190 common fsetxattr sys_fsetxattr
200	191 common getxattr sys_getxattr	200	191 common getxattr sys_getxattr
201	192 common lgetxattr sys_lgetxattr	201	192 common lgetxattr sys_lgetxattr
202	193 common fgetxattr sys_fgetxattr	202	193 common fgetxattr sys_fgetxattr
203	194 common listxattr sys_listxattr	203	194 common listxattr sys_listxattr
204	195 common llistxattr sys_llistxattr	204	195 common llistxattr sys_llistxattr
205	196 common flistxattr sys_flistxattr	205	196 common flistxattr sys_flistxattr
206	197 common removexattr sys_removexattr	206	197 common removexattr sys_removexattr
207	198 common lremovexattr sys_lremovexattr	207	198 common lremovexattr sys_lremovexattr
208	199 common fremovexattr sys_fremovexattr	208	199 common fremovexattr sys_fremovexattr
209	200 common tkill sys_tkill	209	200 common tkill sys_tkill
210	201 common time sys_time	210	201 common time sys_time
211	202 common futex sys_futex	211	202 common futex sys_futex
212	203 common sched_setaffinity sys_sched_setaffinity	212	203 common sched_setaffinity sys_sched_setaffinity
213	204 common sched_getaffinity sys_sched_getaffinity	213	204 common sched_getaffinity sys_sched_getaffinity
214	205 64 set_thread_area	214	205 64 set_thread_area
215	206 common io_setup sys_io_setup	215	206 common io_setup sys_io_setup
216	207 common io_destroy sys_io_destroy	216	207 common io_destroy sys_io_destroy
217	208 common io_getevents sys_io_getevents	217	208 common io_getevents sys_io_getevents
218	209 common io_submit sys_io_submit	218	209 common io_submit sys_io_submit
219	210 common io_cancel sys_io_cancel	219	210 common io_cancel sys_io_cancel
220	211 64 get_thread_area	220	211 64 get_thread_area
221	212 common lookup_dcookie sys_lookup_dcookie	221	212 common lookup_dcookie sys_lookup_dcookie
222	213 common epoll_create sys_epoll_create	222	213 common epoll_create sys_epoll_create
223	214 64 epoll_ctl_old	223	214 64 epoll_ctl_old
224	215 64 epoll_wait_old	224	215 64 epoll_wait_old
225	216 common remap_file_pages sys_remap_file_pages	225	216 common remap_file_pages sys_remap_file_pages
226	217 common getdents64 sys_getdents64	226	217 common getdents64 sys_getdents64
227	218 common set_tid_address sys_set_tid_address	227	218 common set_tid_address sys_set_tid_address
228	219 common restart_syscall sys_restart_syscall	228	219 common restart_syscall sys_restart_syscall
229	220 common semtimedop sys_semtimedop	229	220 common semtimedop sys_semtimedop
230	221 common fadvise64 sys_fadvise64	230	221 common fadvise64 sys_fadvise64
231	222 64 timer_create sys_timer_create	231	222 64 timer_create sys_timer_create
232	223 common timer_settime sys_timer_settime	232	223 common timer_settime sys_timer_settime
233	224 common timer_gettime sys_timer_gettime	233	224 common timer_gettime sys_timer_gettime
234	225 common timer_getoverrun sys_timer_getoverrun	234	225 common timer_getoverrun sys_timer_getoverrun
235	226 common timer_delete sys_timer_delete	235	226 common timer_delete sys_timer_delete
236	227 common clock_settime sys_clock_settime	236	227 common clock_settime sys_clock_settime
237	228 common clock_gettime sys_clock_gettime	237	228 common clock_gettime sys_clock_gettime
238	229 common clock_getres sys_clock_getres	238	229 common clock_getres sys_clock_getres
239	230 common clock_nanosleep sys_clock_nanosleep	239	230 common clock_nanosleep sys_clock_nanosleep
240	231 common exit_group sys_exit_group	240	231 common exit_group sys_exit_group
241	232 common epoll_wait sys_epoll_wait	241	232 common epoll_wait sys_epoll_wait
242	233 common epoll_ctl sys_epoll_ctl	242	233 common epoll_ctl sys_epoll_ctl
243	234 common tgkill sys_tgkill	243	234 common tgkill sys_tgkill
244	235 common utimes sys_utimes	244	235 common utimes sys_utimes
245	236 64 vserver	245	236 64 vserver
246	237 common mbind sys_mbind	246	237 common mbind sys_mbind
247	238 common set_mempolicy sys_set_mempolicy	247	238 common set_mempolicy sys_set_mempolicy
248	239 common get_mempolicy sys_get_mempolicy	248	239 common get_mempolicy sys_get_mempolicy
249	240 common mq_open sys_mq_open	249	240 common mq_open sys_mq_open
250	241 common mq_unlink sys_mq_unlink	250	241 common mq_unlink sys_mq_unlink
251	242 common mq_timedsend sys_mq_timedsend	251	242 common mq_timedsend sys_mq_timedsend
252	243 common mq_timedreceive sys_mq_timedreceive	252	243 common mq_timedreceive sys_mq_timedreceive
253	244 64 mq_notify sys_mq_notify	253	244 64 mq_notify sys_mq_notify
254	245 common mq_getsetattr sys_mq_getsetattr	254	245 common mq_getsetattr sys_mq_getsetattr
255	246 64 kexec_load sys_kexec_load	255	246 64 kexec_load sys_kexec_load
256	247 64 waitid sys_waitid	256	247 64 waitid sys_waitid
257	248 common add_key sys_add_key	257	248 common add_key sys_add_key
258	249 common request_key sys_request_key	258	249 common request_key sys_request_key
259	250 common keyctl sys_keyctl	259	250 common keyctl sys_keyctl
260	251 common ioprio_set sys_ioprio_set	260	251 common ioprio_set sys_ioprio_set
261	252 common ioprio_get sys_ioprio_get	261	252 common ioprio_get sys_ioprio_get
262	253 common inotify_init sys_inotify_init	262	253 common inotify_init sys_inotify_init
263	254 common inotify_add_watch sys_inotify_add_watch	263	254 common inotify_add_watch sys_inotify_add_watch
264	255 common inotify_rm_watch sys_inotify_rm_watch	264	255 common inotify_rm_watch sys_inotify_rm_watch
265	256 common migrate_pages sys_migrate_pages	265	256 common migrate_pages sys_migrate_pages
266	257 common openat sys_openat	266	257 common openat sys_openat
267	258 common mkdirat sys_mkdirat	267	258 common mkdirat sys_mkdirat
268	259 common mknodat sys_mknodat	268	259 common mknodat sys_mknodat
269	260 common fchownat sys_fchownat	269	260 common fchownat sys_fchownat
270	261 common futimesat sys_futimesat	270	261 common futimesat sys_futimesat
271	262 common newfstatat sys_newfstatat	271	262 common newfstatat sys_newfstatat
272	263 common unlinkat sys_unlinkat	272	263 common unlinkat sys_unlinkat
273	264 common renameat sys_renameat	273	264 common renameat sys_renameat
274	265 common linkat sys_linkat	274	265 common linkat sys_linkat
275	266 common symlinkat sys_symlinkat	275	266 common symlinkat sys_symlinkat
276	267 common readlinkat sys_readlinkat	276	267 common readlinkat sys_readlinkat
277	268 common fchmodat sys_fchmodat	277	268 common fchmodat sys_fchmodat
278	269 common faccessat sys_faccessat	278	269 common faccessat sys_faccessat
279	270 common pselect6 sys_pselect6	279	270 common pselect6 sys_pselect6
280	271 common ppoll sys_ppoll	280	271 common ppoll sys_ppoll
281	272 common unshare sys_unshare	281	272 common unshare sys_unshare
282	273 64 set_robust_list sys_set_robust_list	282	273 64 set_robust_list sys_set_robust_list
283	274 64 get_robust_list sys_get_robust_list	283	274 64 get_robust_list sys_get_robust_list
284	275 common splice sys_splice	284	275 common splice sys_splice
285	276 common tee sys_tee	285	276 common tee sys_tee
286	277 common sync_file_range sys_sync_file_range	286	277 common sync_file_range sys_sync_file_range
287	278 64 vmsplice sys_vmsplice	287	278 64 vmsplice sys_vmsplice
288	279 64 move_pages sys_move_pages	288	279 64 move_pages sys_move_pages
289	280 common utimensat sys_utimensat	289	280 common utimensat sys_utimensat
290	281 common epoll_pwait sys_epoll_pwait	290	281 common epoll_pwait sys_epoll_pwait
291	282 common signalfd sys_signalfd	291	282 common signalfd sys_signalfd
292	283 common timerfd_create sys_timerfd_create	292	283 common timerfd_create sys_timerfd_create
293	284 common eventfd sys_eventfd	293	284 common eventfd sys_eventfd
294	285 common fallocate sys_fallocate	294	285 common fallocate sys_fallocate
295	286 common timerfd_settime sys_timerfd_settime	295	286 common timerfd_settime sys_timerfd_settime
296	287 common timerfd_gettime sys_timerfd_gettime	296	287 common timerfd_gettime sys_timerfd_gettime
297	288 common accept4 sys_accept4	297	288 common accept4 sys_accept4
298	289 common signalfd4 sys_signalfd4	298	289 common signalfd4 sys_signalfd4
299	290 common eventfd2 sys_eventfd2	299	290 common eventfd2 sys_eventfd2
300	291 common epoll_create1 sys_epoll_create1	300	291 common epoll_create1 sys_epoll_create1
301	292 common dup3 sys_dup3	301	292 common dup3 sys_dup3
302	293 common pipe2 sys_pipe2	302	293 common pipe2 sys_pipe2
303	294 common inotify_init1 sys_inotify_init1	303	294 common inotify_init1 sys_inotify_init1
304	295 64 preadv sys_preadv	304	295 64 preadv sys_preadv
305	296 64 pwritev sys_pwritev	305	296 64 pwritev sys_pwritev
306	297 64 rt_tgsigqueueinfo sys_rt_tgsigqueueinfo	306	297 64 rt_tgsigqueueinfo sys_rt_tgsigqueueinfo
307	298 common perf_event_open sys_perf_event_open	307	298 common perf_event_open sys_perf_event_open
308	299 64 recvmmsg sys_recvmmsg	308	299 64 recvmmsg sys_recvmmsg
309	300 common fanotify_init sys_fanotify_init	309	300 common fanotify_init sys_fanotify_init
310	301 common fanotify_mark sys_fanotify_mark	310	301 common fanotify_mark sys_fanotify_mark
311	302 common prlimit64 sys_prlimit64	311	302 common prlimit64 sys_prlimit64
312	303 common name_to_handle_at sys_name_to_handle_at	312	303 common name_to_handle_at sys_name_to_handle_at
313	304 common open_by_handle_at sys_open_by_handle_at	313	304 common open_by_handle_at sys_open_by_handle_at
314	305 common clock_adjtime sys_clock_adjtime	314	305 common clock_adjtime sys_clock_adjtime
315	306 common syncfs sys_syncfs	315	306 common syncfs sys_syncfs
316	307 64 sendmmsg sys_sendmmsg	316	307 64 sendmmsg sys_sendmmsg
317	308 common setns sys_setns	317	308 common setns sys_setns
318	309 common getcpu sys_getcpu	318	309 common getcpu sys_getcpu
319	310 64 process_vm_readv sys_process_vm_readv	319	310 64 process_vm_readv sys_process_vm_readv
320	311 64 process_vm_writev sys_process_vm_writev	320	311 64 process_vm_writev sys_process_vm_writev
321	312 common kcmp sys_kcmp	321	312 common kcmp sys_kcmp
322		322
323	#	323	#
324	# x32-specific system call numbers start at 512 to avoid cache impact	324	# x32-specific system call numbers start at 512 to avoid cache impact
325	# for native 64-bit operation.	325	# for native 64-bit operation.
326	#	326	#
327	512 x32 rt_sigaction sys32_rt_sigaction	327	512 x32 rt_sigaction sys32_rt_sigaction
328	513 x32 rt_sigreturn stub_x32_rt_sigreturn	328	513 x32 rt_sigreturn stub_x32_rt_sigreturn
329	514 x32 ioctl compat_sys_ioctl	329	514 x32 ioctl compat_sys_ioctl
330	515 x32 readv compat_sys_readv	330	515 x32 readv compat_sys_readv
331	516 x32 writev compat_sys_writev	331	516 x32 writev compat_sys_writev
332	517 x32 recvfrom compat_sys_recvfrom	332	517 x32 recvfrom compat_sys_recvfrom
333	518 x32 sendmsg compat_sys_sendmsg	333	518 x32 sendmsg compat_sys_sendmsg
334	519 x32 recvmsg compat_sys_recvmsg	334	519 x32 recvmsg compat_sys_recvmsg
335	520 x32 execve stub_x32_execve	335	520 x32 execve stub_x32_execve
336	521 x32 ptrace compat_sys_ptrace	336	521 x32 ptrace compat_sys_ptrace
337	522 x32 rt_sigpending sys32_rt_sigpending	337	522 x32 rt_sigpending sys32_rt_sigpending
338	523 x32 rt_sigtimedwait compat_sys_rt_sigtimedwait	338	523 x32 rt_sigtimedwait compat_sys_rt_sigtimedwait
339	524 x32 rt_sigqueueinfo sys32_rt_sigqueueinfo	339	524 x32 rt_sigqueueinfo sys32_rt_sigqueueinfo
340	525 x32 sigaltstack stub_x32_sigaltstack	340	525 x32 sigaltstack compat_sys_sigaltstack
341	526 x32 timer_create compat_sys_timer_create	341	526 x32 timer_create compat_sys_timer_create
342	527 x32 mq_notify compat_sys_mq_notify	342	527 x32 mq_notify compat_sys_mq_notify
343	528 x32 kexec_load compat_sys_kexec_load	343	528 x32 kexec_load compat_sys_kexec_load
344	529 x32 waitid compat_sys_waitid	344	529 x32 waitid compat_sys_waitid
345	530 x32 set_robust_list compat_sys_set_robust_list	345	530 x32 set_robust_list compat_sys_set_robust_list
346	531 x32 get_robust_list compat_sys_get_robust_list	346	531 x32 get_robust_list compat_sys_get_robust_list
347	532 x32 vmsplice compat_sys_vmsplice	347	532 x32 vmsplice compat_sys_vmsplice
348	533 x32 move_pages compat_sys_move_pages	348	533 x32 move_pages compat_sys_move_pages
349	534 x32 preadv compat_sys_preadv64	349	534 x32 preadv compat_sys_preadv64
350	535 x32 pwritev compat_sys_pwritev64	350	535 x32 pwritev compat_sys_pwritev64
351	536 x32 rt_tgsigqueueinfo compat_sys_rt_tgsigqueueinfo	351	536 x32 rt_tgsigqueueinfo compat_sys_rt_tgsigqueueinfo
352	537 x32 recvmmsg compat_sys_recvmmsg	352	537 x32 recvmmsg compat_sys_recvmmsg
353	538 x32 sendmmsg compat_sys_sendmmsg	353	538 x32 sendmmsg compat_sys_sendmmsg
354	539 x32 process_vm_readv compat_sys_process_vm_readv	354	539 x32 process_vm_readv compat_sys_process_vm_readv
355	540 x32 process_vm_writev compat_sys_process_vm_writev	355	540 x32 process_vm_writev compat_sys_process_vm_writev
356	541 x32 setsockopt compat_sys_setsockopt	356	541 x32 setsockopt compat_sys_setsockopt
357	542 x32 getsockopt compat_sys_getsockopt	357	542 x32 getsockopt compat_sys_getsockopt
358		358

include/linux/compat.h

Diff comments View file @ 9026843

 #ifndef _LINUX_COMPAT_H
 #define _LINUX_COMPAT_H
 /*
  * These are the type definitions for the architecture specific
  * syscall compatibility layer.
  */
 #ifdef CONFIG_COMPAT
 #include <linux/stat.h>
 #include <linux/param.h>	/* for HZ */
 #include <linux/sem.h>
 #include <linux/socket.h>
 #include <linux/if.h>
 #include <linux/fs.h>
 #include <linux/aio_abi.h>	/* for aio_context_t */
 #include <asm/compat.h>
 #include <asm/siginfo.h>
 #include <asm/signal.h>
 #ifndef COMPAT_USE_64BIT_TIME
 #define COMPAT_USE_64BIT_TIME 0
 #endif
 #ifndef __SC_DELOUSE
 #define __SC_DELOUSE(t,v) ((t)(unsigned long)(v))
 #endif
 #define __SC_CCAST1(t1, a1)      __SC_DELOUSE(t1,a1)
 #define __SC_CCAST2(t2, a2, ...) __SC_DELOUSE(t2,a2), __SC_CCAST1(__VA_ARGS__)
 #define __SC_CCAST3(t3, a3, ...) __SC_DELOUSE(t3,a3), __SC_CCAST2(__VA_ARGS__)
 #define __SC_CCAST4(t4, a4, ...) __SC_DELOUSE(t4,a4), __SC_CCAST3(__VA_ARGS__)
 #define __SC_CCAST5(t5, a5, ...) __SC_DELOUSE(t5,a5), __SC_CCAST4(__VA_ARGS__)
 #define __SC_CCAST6(t6, a6, ...) __SC_DELOUSE(t6,a6), __SC_CCAST5(__VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE1(name, ...) \
         COMPAT_SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE2(name, ...) \
 	COMPAT_SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE3(name, ...) \
 	COMPAT_SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE4(name, ...) \
 	COMPAT_SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE5(name, ...) \
 	COMPAT_SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
 #define COMPAT_SYSCALL_DEFINE6(name, ...) \
 	COMPAT_SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)
 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
 #define COMPAT_SYSCALL_DEFINEx(x, name, ...)				\
 	asmlinkage long compat_sys##name(__SC_DECL##x(__VA_ARGS__));	\
 	static inline long C_SYSC##name(__SC_DECL##x(__VA_ARGS__));	\
 	asmlinkage long compat_SyS##name(__SC_LONG##x(__VA_ARGS__))	\
 	{								\
 		return (long) C_SYSC##name(__SC_CCAST##x(__VA_ARGS__));	\
 	}								\
 	SYSCALL_ALIAS(compat_sys##name, compat_SyS##name);		\
 	static inline long C_SYSC##name(__SC_DECL##x(__VA_ARGS__))
 #else /* CONFIG_HAVE_SYSCALL_WRAPPERS */
 #define COMPAT_SYSCALL_DEFINEx(x, name, ...)				\
 	asmlinkage long compat_sys##name(__SC_DECL##x(__VA_ARGS__))
 #endif /* CONFIG_HAVE_SYSCALL_WRAPPERS */
 #ifndef compat_user_stack_pointer
 #define compat_user_stack_pointer() current_user_stack_pointer()
 #endif
+#ifdef CONFIG_GENERIC_SIGALTSTACK
+#ifndef compat_sigaltstack	/* we'll need that for MIPS */
+typedef struct compat_sigaltstack {
+	compat_uptr_t			ss_sp;
+	int				ss_flags;
+	compat_size_t			ss_size;
+} compat_stack_t;
+#endif
+#endif
 #define compat_jiffies_to_clock_t(x)	\
 		(((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
 typedef __compat_uid32_t	compat_uid_t;
 typedef __compat_gid32_t	compat_gid_t;
 struct compat_sel_arg_struct;
 struct rusage;
 struct compat_itimerspec {
 	struct compat_timespec it_interval;
 	struct compat_timespec it_value;
 };
 struct compat_utimbuf {
 	compat_time_t		actime;
 	compat_time_t		modtime;
 };
 struct compat_itimerval {
 	struct compat_timeval	it_interval;
 	struct compat_timeval	it_value;
 };
 struct compat_tms {
 	compat_clock_t		tms_utime;
 	compat_clock_t		tms_stime;
 	compat_clock_t		tms_cutime;
 	compat_clock_t		tms_cstime;
 };
 struct compat_timex {
 	compat_uint_t modes;
 	compat_long_t offset;
 	compat_long_t freq;
 	compat_long_t maxerror;
 	compat_long_t esterror;
 	compat_int_t status;
 	compat_long_t constant;
 	compat_long_t precision;
 	compat_long_t tolerance;
 	struct compat_timeval time;
 	compat_long_t tick;
 	compat_long_t ppsfreq;
 	compat_long_t jitter;
 	compat_int_t shift;
 	compat_long_t stabil;
 	compat_long_t jitcnt;
 	compat_long_t calcnt;
 	compat_long_t errcnt;
 	compat_long_t stbcnt;
 	compat_int_t tai;
 	compat_int_t:32; compat_int_t:32; compat_int_t:32; compat_int_t:32;
 	compat_int_t:32; compat_int_t:32; compat_int_t:32; compat_int_t:32;
 	compat_int_t:32; compat_int_t:32; compat_int_t:32;
 };
 #define _COMPAT_NSIG_WORDS	(_COMPAT_NSIG / _COMPAT_NSIG_BPW)
 typedef struct {
 	compat_sigset_word	sig[_COMPAT_NSIG_WORDS];
 } compat_sigset_t;
 /*
  * These functions operate strictly on struct compat_time*
  */
 extern int get_compat_timespec(struct timespec *,
 			       const struct compat_timespec __user *);
 extern int put_compat_timespec(const struct timespec *,
 			       struct compat_timespec __user *);
 extern int get_compat_timeval(struct timeval *,
 			      const struct compat_timeval __user *);
 extern int put_compat_timeval(const struct timeval *,
 			      struct compat_timeval __user *);
 /*
  * These functions operate on 32- or 64-bit specs depending on
  * COMPAT_USE_64BIT_TIME, hence the void user pointer arguments and the
  * naming as compat_get/put_ rather than get/put_compat_.
  */
 extern int compat_get_timespec(struct timespec *, const void __user *);
 extern int compat_put_timespec(const struct timespec *, void __user *);
 extern int compat_get_timeval(struct timeval *, const void __user *);
 extern int compat_put_timeval(const struct timeval *, void __user *);
 struct compat_iovec {
 	compat_uptr_t	iov_base;
 	compat_size_t	iov_len;
 };
 struct compat_rlimit {
 	compat_ulong_t	rlim_cur;
 	compat_ulong_t	rlim_max;
 };
 struct compat_rusage {
 	struct compat_timeval ru_utime;
 	struct compat_timeval ru_stime;
 	compat_long_t	ru_maxrss;
 	compat_long_t	ru_ixrss;
 	compat_long_t	ru_idrss;
 	compat_long_t	ru_isrss;
 	compat_long_t	ru_minflt;
 	compat_long_t	ru_majflt;
 	compat_long_t	ru_nswap;
 	compat_long_t	ru_inblock;
 	compat_long_t	ru_oublock;
 	compat_long_t	ru_msgsnd;
 	compat_long_t	ru_msgrcv;
 	compat_long_t	ru_nsignals;
 	compat_long_t	ru_nvcsw;
 	compat_long_t	ru_nivcsw;
 };
 extern int put_compat_rusage(const struct rusage *,
 			     struct compat_rusage __user *);
 struct compat_siginfo;
 extern asmlinkage long compat_sys_waitid(int, compat_pid_t,
 		struct compat_siginfo __user *, int,
 		struct compat_rusage __user *);
 struct compat_dirent {
 	u32		d_ino;
 	compat_off_t	d_off;
 	u16		d_reclen;
 	char		d_name[256];
 };
 struct compat_ustat {
 	compat_daddr_t		f_tfree;
 	compat_ino_t		f_tinode;
 	char			f_fname[6];
 	char			f_fpack[6];
 };
 #define COMPAT_SIGEV_PAD_SIZE	((SIGEV_MAX_SIZE/sizeof(int)) - 3)
 typedef struct compat_sigevent {
 	compat_sigval_t sigev_value;
 	compat_int_t sigev_signo;
 	compat_int_t sigev_notify;
 	union {
 		compat_int_t _pad[COMPAT_SIGEV_PAD_SIZE];
 		compat_int_t _tid;
 		struct {
 			compat_uptr_t _function;
 			compat_uptr_t _attribute;
 		} _sigev_thread;
 	} _sigev_un;
 } compat_sigevent_t;
 struct compat_ifmap {
 	compat_ulong_t mem_start;
 	compat_ulong_t mem_end;
 	unsigned short base_addr;
 	unsigned char irq;
 	unsigned char dma;
 	unsigned char port;
 };
 struct compat_if_settings {
 	unsigned int type;	/* Type of physical device or protocol */
 	unsigned int size;	/* Size of the data allocated by the caller */
 	compat_uptr_t ifs_ifsu;	/* union of pointers */
 };
 struct compat_ifreq {
 	union {
 		char	ifrn_name[IFNAMSIZ];    /* if name, e.g. "en0" */
 	} ifr_ifrn;
 	union {
 		struct	sockaddr ifru_addr;
 		struct	sockaddr ifru_dstaddr;
 		struct	sockaddr ifru_broadaddr;
 		struct	sockaddr ifru_netmask;
 		struct	sockaddr ifru_hwaddr;
 		short	ifru_flags;
 		compat_int_t	ifru_ivalue;
 		compat_int_t	ifru_mtu;
 		struct	compat_ifmap ifru_map;
 		char	ifru_slave[IFNAMSIZ];   /* Just fits the size */
 		char	ifru_newname[IFNAMSIZ];
 		compat_caddr_t	ifru_data;
 		struct	compat_if_settings ifru_settings;
 	} ifr_ifru;
 };
 struct compat_ifconf {
 	compat_int_t	ifc_len;                /* size of buffer */
 	compat_caddr_t  ifcbuf;
 };
 struct compat_robust_list {
 	compat_uptr_t			next;
 };
 struct compat_robust_list_head {
 	struct compat_robust_list	list;
 	compat_long_t			futex_offset;
 	compat_uptr_t			list_op_pending;
 };
 struct compat_statfs;
 struct compat_statfs64;
 struct compat_old_linux_dirent;
 struct compat_linux_dirent;
 struct linux_dirent64;
 struct compat_msghdr;
 struct compat_mmsghdr;
 struct compat_sysinfo;
 struct compat_sysctl_args;
 struct compat_kexec_segment;
 struct compat_mq_attr;
 struct compat_msgbuf;
 extern void compat_exit_robust_list(struct task_struct *curr);
 asmlinkage long
 compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
 			   compat_size_t len);
 asmlinkage long
 compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
 			   compat_size_t __user *len_ptr);
 #ifdef CONFIG_ARCH_WANT_OLD_COMPAT_IPC
 long compat_sys_semctl(int first, int second, int third, void __user *uptr);
 long compat_sys_msgsnd(int first, int second, int third, void __user *uptr);
 long compat_sys_msgrcv(int first, int second, int msgtyp, int third,
 		int version, void __user *uptr);
 long compat_sys_shmat(int first, int second, compat_uptr_t third, int version,
 		void __user *uptr);
 #else
 long compat_sys_semctl(int semid, int semnum, int cmd, int arg);
 long compat_sys_msgsnd(int msqid, struct compat_msgbuf __user *msgp,
 		compat_ssize_t msgsz, int msgflg);
 long compat_sys_msgrcv(int msqid, struct compat_msgbuf __user *msgp,
 		compat_ssize_t msgsz, long msgtyp, int msgflg);
 long compat_sys_shmat(int shmid, compat_uptr_t shmaddr, int shmflg);
 #endif
 long compat_sys_msgctl(int first, int second, void __user *uptr);
 long compat_sys_shmctl(int first, int second, void __user *uptr);
 long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
 		unsigned nsems, const struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_keyctl(u32 option,
 			      u32 arg2, u32 arg3, u32 arg4, u32 arg5);
 asmlinkage long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u32);
 asmlinkage ssize_t compat_sys_readv(unsigned long fd,
 		const struct compat_iovec __user *vec, unsigned long vlen);
 asmlinkage ssize_t compat_sys_writev(unsigned long fd,
 		const struct compat_iovec __user *vec, unsigned long vlen);
 asmlinkage ssize_t compat_sys_preadv(unsigned long fd,
 		const struct compat_iovec __user *vec,
 		unsigned long vlen, u32 pos_low, u32 pos_high);
 asmlinkage ssize_t compat_sys_pwritev(unsigned long fd,
 		const struct compat_iovec __user *vec,
 		unsigned long vlen, u32 pos_low, u32 pos_high);
 asmlinkage long compat_sys_execve(const char __user *filename, const compat_uptr_t __user *argv,
 		     const compat_uptr_t __user *envp);
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
 		compat_ulong_t __user *outp, compat_ulong_t __user *exp,
 		struct compat_timeval __user *tvp);
 asmlinkage long compat_sys_old_select(struct compat_sel_arg_struct __user *arg);
 asmlinkage long compat_sys_wait4(compat_pid_t pid,
 				 compat_uint_t __user *stat_addr, int options,
 				 struct compat_rusage __user *ru);
 #define BITS_PER_COMPAT_LONG    (8*sizeof(compat_long_t))
 #define BITS_TO_COMPAT_LONGS(bits) \
 	(((bits)+BITS_PER_COMPAT_LONG-1)/BITS_PER_COMPAT_LONG)
 long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
 		       unsigned long bitmap_size);
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
 		       unsigned long bitmap_size);
 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from);
 int copy_siginfo_to_user32(struct compat_siginfo __user *to, siginfo_t *from);
 int get_compat_sigevent(struct sigevent *event,
 		const struct compat_sigevent __user *u_event);
 long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid, compat_pid_t pid, int sig,
 				  struct compat_siginfo __user *uinfo);
 static inline int compat_timeval_compare(struct compat_timeval *lhs,
 					struct compat_timeval *rhs)
 {
 	if (lhs->tv_sec < rhs->tv_sec)
 		return -1;
 	if (lhs->tv_sec > rhs->tv_sec)
 		return 1;
 	return lhs->tv_usec - rhs->tv_usec;
 }
 static inline int compat_timespec_compare(struct compat_timespec *lhs,
 					struct compat_timespec *rhs)
 {
 	if (lhs->tv_sec < rhs->tv_sec)
 		return -1;
 	if (lhs->tv_sec > rhs->tv_sec)
 		return 1;
 	return lhs->tv_nsec - rhs->tv_nsec;
 }
 extern int get_compat_itimerspec(struct itimerspec *dst,
 				 const struct compat_itimerspec __user *src);
 extern int put_compat_itimerspec(struct compat_itimerspec __user *dst,
 				 const struct itimerspec *src);
 asmlinkage long compat_sys_gettimeofday(struct compat_timeval __user *tv,
 		struct timezone __user *tz);
 asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
 		struct timezone __user *tz);
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 extern int compat_printk(const char *fmt, ...);
 extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
 asmlinkage long compat_sys_migrate_pages(compat_pid_t pid,
 		compat_ulong_t maxnode, const compat_ulong_t __user *old_nodes,
 		const compat_ulong_t __user *new_nodes);
 extern int compat_ptrace_request(struct task_struct *child,
 				 compat_long_t request,
 				 compat_ulong_t addr, compat_ulong_t data);
 extern long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
 			       compat_ulong_t addr, compat_ulong_t data);
 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
 				  compat_long_t addr, compat_long_t data);
 /*
  * epoll (fs/eventpoll.c) compat bits follow ...
  */
 struct epoll_event;
 #define compat_epoll_event	epoll_event
 asmlinkage long compat_sys_epoll_pwait(int epfd,
 			struct compat_epoll_event __user *events,
 			int maxevents, int timeout,
 			const compat_sigset_t __user *sigmask,
 			compat_size_t sigsetsize);
 asmlinkage long compat_sys_utime(const char __user *filename,
 				 struct compat_utimbuf __user *t);
 asmlinkage long compat_sys_utimensat(unsigned int dfd,
 				     const char __user *filename,
 				     struct compat_timespec __user *t,
 				     int flags);
 asmlinkage long compat_sys_time(compat_time_t __user *tloc);
 asmlinkage long compat_sys_stime(compat_time_t __user *tptr);
 asmlinkage long compat_sys_signalfd(int ufd,
 				    const compat_sigset_t __user *sigmask,
 				    compat_size_t sigsetsize);
 asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
 				   const struct compat_itimerspec __user *utmr,
 				   struct compat_itimerspec __user *otmr);
 asmlinkage long compat_sys_timerfd_gettime(int ufd,
 				   struct compat_itimerspec __user *otmr);
 asmlinkage long compat_sys_move_pages(pid_t pid, unsigned long nr_page,
 				      __u32 __user *pages,
 				      const int __user *nodes,
 				      int __user *status,
 				      int flags);
 asmlinkage long compat_sys_futimesat(unsigned int dfd,
 				     const char __user *filename,
 				     struct compat_timeval __user *t);
 asmlinkage long compat_sys_utimes(const char __user *filename,
 				  struct compat_timeval __user *t);
 asmlinkage long compat_sys_newstat(const char __user *filename,
 				   struct compat_stat __user *statbuf);
 asmlinkage long compat_sys_newlstat(const char __user *filename,
 				    struct compat_stat __user *statbuf);
 asmlinkage long compat_sys_newfstatat(unsigned int dfd,
 				      const char __user *filename,
 				      struct compat_stat __user *statbuf,
 				      int flag);
 asmlinkage long compat_sys_newfstat(unsigned int fd,
 				    struct compat_stat __user *statbuf);
 asmlinkage long compat_sys_statfs(const char __user *pathname,
 				  struct compat_statfs __user *buf);
 asmlinkage long compat_sys_fstatfs(unsigned int fd,
 				   struct compat_statfs __user *buf);
 asmlinkage long compat_sys_statfs64(const char __user *pathname,
 				    compat_size_t sz,
 				    struct compat_statfs64 __user *buf);
 asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
 				     struct compat_statfs64 __user *buf);
 asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
 				   unsigned long arg);
 asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
 				 unsigned long arg);
 asmlinkage long compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p);
 asmlinkage long compat_sys_io_getevents(aio_context_t ctx_id,
 					unsigned long min_nr,
 					unsigned long nr,
 					struct io_event __user *events,
 					struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_io_submit(aio_context_t ctx_id, int nr,
 				     u32 __user *iocb);
 asmlinkage long compat_sys_mount(const char __user *dev_name,
 				 const char __user *dir_name,
 				 const char __user *type, unsigned long flags,
 				 const void __user *data);
 asmlinkage long compat_sys_old_readdir(unsigned int fd,
 				       struct compat_old_linux_dirent __user *,
 				       unsigned int count);
 asmlinkage long compat_sys_getdents(unsigned int fd,
 				    struct compat_linux_dirent __user *dirent,
 				    unsigned int count);
 asmlinkage long compat_sys_getdents64(unsigned int fd,
 				      struct linux_dirent64 __user *dirent,
 				      unsigned int count);
 asmlinkage long compat_sys_vmsplice(int fd, const struct compat_iovec __user *,
 				    unsigned int nr_segs, unsigned int flags);
 asmlinkage long compat_sys_open(const char __user *filename, int flags,
 				umode_t mode);
 asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
 				  int flags, umode_t mode);
 asmlinkage long compat_sys_open_by_handle_at(int mountdirfd,
 					     struct file_handle __user *handle,
 					     int flags);
 asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
 				    compat_ulong_t __user *outp,
 				    compat_ulong_t __user *exp,
 				    struct compat_timespec __user *tsp,
 				    void __user *sig);
 asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
 				 unsigned int nfds,
 				 struct compat_timespec __user *tsp,
 				 const compat_sigset_t __user *sigmask,
 				 compat_size_t sigsetsize);
 asmlinkage long compat_sys_signalfd4(int ufd,
 				     const compat_sigset_t __user *sigmask,
 				     compat_size_t sigsetsize, int flags);
 asmlinkage long compat_sys_get_mempolicy(int __user *policy,
 					 compat_ulong_t __user *nmask,
 					 compat_ulong_t maxnode,
 					 compat_ulong_t addr,
 					 compat_ulong_t flags);
 asmlinkage long compat_sys_set_mempolicy(int mode, compat_ulong_t __user *nmask,
 					 compat_ulong_t maxnode);
 asmlinkage long compat_sys_mbind(compat_ulong_t start, compat_ulong_t len,
 				 compat_ulong_t mode,
 				 compat_ulong_t __user *nmask,
 				 compat_ulong_t maxnode, compat_ulong_t flags);
 asmlinkage long compat_sys_setsockopt(int fd, int level, int optname,
 				      char __user *optval, unsigned int optlen);
 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg,
 				   unsigned flags);
 asmlinkage long compat_sys_sendmmsg(int fd, struct compat_mmsghdr __user *mmsg,
 				    unsigned vlen, unsigned int flags);
 asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg,
 				   unsigned int flags);
 asmlinkage long compat_sys_recv(int fd, void __user *buf, size_t len,
 				unsigned flags);
 asmlinkage long compat_sys_recvfrom(int fd, void __user *buf, size_t len,
 			    unsigned flags, struct sockaddr __user *addr,
 			    int __user *addrlen);
 asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
 				    unsigned vlen, unsigned int flags,
 				    struct compat_timespec __user *timeout);
 asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
 				     struct compat_timespec __user *rmtp);
 asmlinkage long compat_sys_getitimer(int which,
 				     struct compat_itimerval __user *it);
 asmlinkage long compat_sys_setitimer(int which,
 				     struct compat_itimerval __user *in,
 				     struct compat_itimerval __user *out);
 asmlinkage long compat_sys_times(struct compat_tms __user *tbuf);
 asmlinkage long compat_sys_setrlimit(unsigned int resource,
 				     struct compat_rlimit __user *rlim);
 asmlinkage long compat_sys_getrlimit(unsigned int resource,
 				     struct compat_rlimit __user *rlim);
 asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru);
 asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
 				     unsigned int len,
 				     compat_ulong_t __user *user_mask_ptr);
 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid,
 				     unsigned int len,
 				     compat_ulong_t __user *user_mask_ptr);
 asmlinkage long compat_sys_timer_create(clockid_t which_clock,
 			struct compat_sigevent __user *timer_event_spec,
 			timer_t __user *created_timer_id);
 asmlinkage long compat_sys_timer_settime(timer_t timer_id, int flags,
 					 struct compat_itimerspec __user *new,
 					 struct compat_itimerspec __user *old);
 asmlinkage long compat_sys_timer_gettime(timer_t timer_id,
 				 struct compat_itimerspec __user *setting);
 asmlinkage long compat_sys_clock_settime(clockid_t which_clock,
 					 struct compat_timespec __user *tp);
 asmlinkage long compat_sys_clock_gettime(clockid_t which_clock,
 					 struct compat_timespec __user *tp);
 asmlinkage long compat_sys_clock_adjtime(clockid_t which_clock,
 					 struct compat_timex __user *tp);
 asmlinkage long compat_sys_clock_getres(clockid_t which_clock,
 					struct compat_timespec __user *tp);
 asmlinkage long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
 					   struct compat_timespec __user *rqtp,
 					   struct compat_timespec __user *rmtp);
 asmlinkage long compat_sys_rt_sigtimedwait(compat_sigset_t __user *uthese,
 		struct compat_siginfo __user *uinfo,
 		struct compat_timespec __user *uts, compat_size_t sigsetsize);
 asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset,
 					 compat_size_t sigsetsize);
 asmlinkage long compat_sys_sysinfo(struct compat_sysinfo __user *info);
 asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
 				 unsigned long arg);
 asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val,
 		struct compat_timespec __user *utime, u32 __user *uaddr2,
 		u32 val3);
 asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,
 				      char __user *optval, int __user *optlen);
 asmlinkage long compat_sys_kexec_load(unsigned long entry,
 				      unsigned long nr_segments,
 				      struct compat_kexec_segment __user *,
 				      unsigned long flags);
 asmlinkage long compat_sys_mq_getsetattr(mqd_t mqdes,
 			const struct compat_mq_attr __user *u_mqstat,
 			struct compat_mq_attr __user *u_omqstat);
 asmlinkage long compat_sys_mq_notify(mqd_t mqdes,
 			const struct compat_sigevent __user *u_notification);
 asmlinkage long compat_sys_mq_open(const char __user *u_name,
 			int oflag, compat_mode_t mode,
 			struct compat_mq_attr __user *u_attr);
 asmlinkage long compat_sys_mq_timedsend(mqd_t mqdes,
 			const char __user *u_msg_ptr,
 			size_t msg_len, unsigned int msg_prio,
 			const struct compat_timespec __user *u_abs_timeout);
 asmlinkage ssize_t compat_sys_mq_timedreceive(mqd_t mqdes,
 			char __user *u_msg_ptr,
 			size_t msg_len, unsigned int __user *u_msg_prio,
 			const struct compat_timespec __user *u_abs_timeout);
 asmlinkage long compat_sys_socketcall(int call, u32 __user *args);
 asmlinkage long compat_sys_sysctl(struct compat_sysctl_args __user *args);
 extern ssize_t compat_rw_copy_check_uvector(int type,
 		const struct compat_iovec __user *uvector,
 		unsigned long nr_segs,
 		unsigned long fast_segs, struct iovec *fast_pointer,
 		struct iovec **ret_pointer);
 extern void __user *compat_alloc_user_space(unsigned long len);
 asmlinkage ssize_t compat_sys_process_vm_readv(compat_pid_t pid,
 		const struct compat_iovec __user *lvec,
 		unsigned long liovcnt, const struct compat_iovec __user *rvec,
 		unsigned long riovcnt, unsigned long flags);
 asmlinkage ssize_t compat_sys_process_vm_writev(compat_pid_t pid,
 		const struct compat_iovec __user *lvec,
 		unsigned long liovcnt, const struct compat_iovec __user *rvec,
 		unsigned long riovcnt, unsigned long flags);
 asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
 				    compat_off_t __user *offset, compat_size_t count);
+#ifdef CONFIG_GENERIC_SIGALTSTACK
+asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
+				       compat_stack_t __user *uoss_ptr);
+int compat_restore_altstack(const compat_stack_t __user *uss);
+#endif
 #else
 #define is_compat_task() (0)
 #endif /* CONFIG_COMPAT */
 #endif /* _LINUX_COMPAT_H */

kernel/signal.c

Diff comments View file @ 9026843

 /*
  *  linux/kernel/signal.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
  *
  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
  *		Changes to use preallocated sigqueue structures
  *		to allow signals to be sent reliably.
  */
 #include <linux/slab.h>
 #include <linux/export.h>
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/fs.h>
 #include <linux/tty.h>
 #include <linux/binfmts.h>
 #include <linux/coredump.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/ptrace.h>
 #include <linux/signal.h>
 #include <linux/signalfd.h>
 #include <linux/ratelimit.h>
 #include <linux/tracehook.h>
 #include <linux/capability.h>
 #include <linux/freezer.h>
 #include <linux/pid_namespace.h>
 #include <linux/nsproxy.h>
 #include <linux/user_namespace.h>
 #include <linux/uprobes.h>
+#include <linux/compat.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/signal.h>
 #include <asm/param.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 #include <asm/siginfo.h>
 #include <asm/cacheflush.h>
 #include "audit.h"	/* audit_signal_info() */
 /*
  * SLAB caches for signal bits.
  */
 static struct kmem_cache *sigqueue_cachep;
 int print_fatal_signals __read_mostly;
 static void __user *sig_handler(struct task_struct *t, int sig)
 {
 	return t->sighand->action[sig - 1].sa.sa_handler;
 }
 static int sig_handler_ignored(void __user *handler, int sig)
 {
 	/* Is it explicitly or implicitly ignored? */
 	return handler == SIG_IGN ||
 		(handler == SIG_DFL && sig_kernel_ignore(sig));
 }
 static int sig_task_ignored(struct task_struct *t, int sig, bool force)
 {
 	void __user *handler;
 	handler = sig_handler(t, sig);
 	if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
 			handler == SIG_DFL && !force)
 		return 1;
 	return sig_handler_ignored(handler, sig);
 }
 static int sig_ignored(struct task_struct *t, int sig, bool force)
 {
 	/*
 	 * Blocked signals are never ignored, since the
 	 * signal handler may change by the time it is
 	 * unblocked.
 	 */
 	if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
 		return 0;
 	if (!sig_task_ignored(t, sig, force))
 		return 0;
 	/*
 	 * Tracers may want to know about even ignored signals.
 	 */
 	return !t->ptrace;
 }
 /*
  * Re-calculate pending state from the set of locally pending
  * signals, globally pending signals, and blocked signals.
  */
 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
 {
 	unsigned long ready;
 	long i;
 	switch (_NSIG_WORDS) {
 	default:
 		for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
 			ready |= signal->sig[i] &~ blocked->sig[i];
 		break;
 	case 4: ready  = signal->sig[3] &~ blocked->sig[3];
 		ready |= signal->sig[2] &~ blocked->sig[2];
 		ready |= signal->sig[1] &~ blocked->sig[1];
 		ready |= signal->sig[0] &~ blocked->sig[0];
 		break;
 	case 2: ready  = signal->sig[1] &~ blocked->sig[1];
 		ready |= signal->sig[0] &~ blocked->sig[0];
 		break;
 	case 1: ready  = signal->sig[0] &~ blocked->sig[0];
 	}
 	return ready !=	0;
 }
 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
 static int recalc_sigpending_tsk(struct task_struct *t)
 {
 	if ((t->jobctl & JOBCTL_PENDING_MASK) ||
 	    PENDING(&t->pending, &t->blocked) ||
 	    PENDING(&t->signal->shared_pending, &t->blocked)) {
 		set_tsk_thread_flag(t, TIF_SIGPENDING);
 		return 1;
 	}
 	/*
 	 * We must never clear the flag in another thread, or in current
 	 * when it's possible the current syscall is returning -ERESTART*.
 	 * So we don't clear it here, and only callers who know they should do.
 	 */
 	return 0;
 }
 /*
  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
  * This is superfluous when called on current, the wakeup is a harmless no-op.
  */
 void recalc_sigpending_and_wake(struct task_struct *t)
 {
 	if (recalc_sigpending_tsk(t))
 		signal_wake_up(t, 0);
 }
 void recalc_sigpending(void)
 {
 	if (!recalc_sigpending_tsk(current) && !freezing(current))
 		clear_thread_flag(TIF_SIGPENDING);
 }
 /* Given the mask, find the first available signal that should be serviced. */
 #define SYNCHRONOUS_MASK \
 	(sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
 	 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
 int next_signal(struct sigpending *pending, sigset_t *mask)
 {
 	unsigned long i, *s, *m, x;
 	int sig = 0;
 	s = pending->signal.sig;
 	m = mask->sig;
 	/*
 	 * Handle the first word specially: it contains the
 	 * synchronous signals that need to be dequeued first.
 	 */
 	x = *s &~ *m;
 	if (x) {
 		if (x & SYNCHRONOUS_MASK)
 			x &= SYNCHRONOUS_MASK;
 		sig = ffz(~x) + 1;
 		return sig;
 	}
 	switch (_NSIG_WORDS) {
 	default:
 		for (i = 1; i < _NSIG_WORDS; ++i) {
 			x = *++s &~ *++m;
 			if (!x)
 				continue;
 			sig = ffz(~x) + i*_NSIG_BPW + 1;
 			break;
 		}
 		break;
 	case 2:
 		x = s[1] &~ m[1];
 		if (!x)
 			break;
 		sig = ffz(~x) + _NSIG_BPW + 1;
 		break;
 	case 1:
 		/* Nothing to do */
 		break;
 	}
 	return sig;
 }
 static inline void print_dropped_signal(int sig)
 {
 	static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
 	if (!print_fatal_signals)
 		return;
 	if (!__ratelimit(&ratelimit_state))
 		return;
 	printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
 				current->comm, current->pid, sig);
 }
 /**
  * task_set_jobctl_pending - set jobctl pending bits
  * @task: target task
  * @mask: pending bits to set
  *
  * Clear @mask from @task->jobctl.  @mask must be subset of
  * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
  * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
  * cleared.  If @task is already being killed or exiting, this function
  * becomes noop.
  *
  * CONTEXT:
  * Must be called with @task->sighand->siglock held.
  *
  * RETURNS:
  * %true if @mask is set, %false if made noop because @task was dying.
  */
 bool task_set_jobctl_pending(struct task_struct *task, unsigned int mask)
 {
 	BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
 			JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
 	BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
 	if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
 		return false;
 	if (mask & JOBCTL_STOP_SIGMASK)
 		task->jobctl &= ~JOBCTL_STOP_SIGMASK;
 	task->jobctl |= mask;
 	return true;
 }
 /**
  * task_clear_jobctl_trapping - clear jobctl trapping bit
  * @task: target task
  *
  * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
  * Clear it and wake up the ptracer.  Note that we don't need any further
  * locking.  @task->siglock guarantees that @task->parent points to the
  * ptracer.
  *
  * CONTEXT:
  * Must be called with @task->sighand->siglock held.
  */
 void task_clear_jobctl_trapping(struct task_struct *task)
 {
 	if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
 		task->jobctl &= ~JOBCTL_TRAPPING;
 		wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
 	}
 }
 /**
  * task_clear_jobctl_pending - clear jobctl pending bits
  * @task: target task
  * @mask: pending bits to clear
  *
  * Clear @mask from @task->jobctl.  @mask must be subset of
  * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
  * STOP bits are cleared together.
  *
  * If clearing of @mask leaves no stop or trap pending, this function calls
  * task_clear_jobctl_trapping().
  *
  * CONTEXT:
  * Must be called with @task->sighand->siglock held.
  */
 void task_clear_jobctl_pending(struct task_struct *task, unsigned int mask)
 {
 	BUG_ON(mask & ~JOBCTL_PENDING_MASK);
 	if (mask & JOBCTL_STOP_PENDING)
 		mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
 	task->jobctl &= ~mask;
 	if (!(task->jobctl & JOBCTL_PENDING_MASK))
 		task_clear_jobctl_trapping(task);
 }
 /**
  * task_participate_group_stop - participate in a group stop
  * @task: task participating in a group stop
  *
  * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
  * Group stop states are cleared and the group stop count is consumed if
  * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
  * stop, the appropriate %SIGNAL_* flags are set.
  *
  * CONTEXT:
  * Must be called with @task->sighand->siglock held.
  *
  * RETURNS:
  * %true if group stop completion should be notified to the parent, %false
  * otherwise.
  */
 static bool task_participate_group_stop(struct task_struct *task)
 {
 	struct signal_struct *sig = task->signal;
 	bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
 	WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
 	task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
 	if (!consume)
 		return false;
 	if (!WARN_ON_ONCE(sig->group_stop_count == 0))
 		sig->group_stop_count--;
 	/*
 	 * Tell the caller to notify completion iff we are entering into a
 	 * fresh group stop.  Read comment in do_signal_stop() for details.
 	 */
 	if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
 		sig->flags = SIGNAL_STOP_STOPPED;
 		return true;
 	}
 	return false;
 }
 /*
  * allocate a new signal queue record
  * - this may be called without locks if and only if t == current, otherwise an
  *   appropriate lock must be held to stop the target task from exiting
  */
 static struct sigqueue *
 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
 {
 	struct sigqueue *q = NULL;
 	struct user_struct *user;
 	/*
 	 * Protect access to @t credentials. This can go away when all
 	 * callers hold rcu read lock.
 	 */
 	rcu_read_lock();
 	user = get_uid(__task_cred(t)->user);
 	atomic_inc(&user->sigpending);
 	rcu_read_unlock();
 	if (override_rlimit ||
 	    atomic_read(&user->sigpending) <=
 			task_rlimit(t, RLIMIT_SIGPENDING)) {
 		q = kmem_cache_alloc(sigqueue_cachep, flags);
 	} else {
 		print_dropped_signal(sig);
 	}
 	if (unlikely(q == NULL)) {
 		atomic_dec(&user->sigpending);
 		free_uid(user);
 	} else {
 		INIT_LIST_HEAD(&q->list);
 		q->flags = 0;
 		q->user = user;
 	}
 	return q;
 }
 static void __sigqueue_free(struct sigqueue *q)
 {
 	if (q->flags & SIGQUEUE_PREALLOC)
 		return;
 	atomic_dec(&q->user->sigpending);
 	free_uid(q->user);
 	kmem_cache_free(sigqueue_cachep, q);
 }
 void flush_sigqueue(struct sigpending *queue)
 {
 	struct sigqueue *q;
 	sigemptyset(&queue->signal);
 	while (!list_empty(&queue->list)) {
 		q = list_entry(queue->list.next, struct sigqueue , list);
 		list_del_init(&q->list);
 		__sigqueue_free(q);
 	}
 }
 /*
  * Flush all pending signals for a task.
  */
 void __flush_signals(struct task_struct *t)
 {
 	clear_tsk_thread_flag(t, TIF_SIGPENDING);
 	flush_sigqueue(&t->pending);
 	flush_sigqueue(&t->signal->shared_pending);
 }
 void flush_signals(struct task_struct *t)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&t->sighand->siglock, flags);
 	__flush_signals(t);
 	spin_unlock_irqrestore(&t->sighand->siglock, flags);
 }
 static void __flush_itimer_signals(struct sigpending *pending)
 {
 	sigset_t signal, retain;
 	struct sigqueue *q, *n;
 	signal = pending->signal;
 	sigemptyset(&retain);
 	list_for_each_entry_safe(q, n, &pending->list, list) {
 		int sig = q->info.si_signo;
 		if (likely(q->info.si_code != SI_TIMER)) {
 			sigaddset(&retain, sig);
 		} else {
 			sigdelset(&signal, sig);
 			list_del_init(&q->list);
 			__sigqueue_free(q);
 		}
 	}
 	sigorsets(&pending->signal, &signal, &retain);
 }
 void flush_itimer_signals(void)
 {
 	struct task_struct *tsk = current;
 	unsigned long flags;
 	spin_lock_irqsave(&tsk->sighand->siglock, flags);
 	__flush_itimer_signals(&tsk->pending);
 	__flush_itimer_signals(&tsk->signal->shared_pending);
 	spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
 }
 void ignore_signals(struct task_struct *t)
 {
 	int i;
 	for (i = 0; i < _NSIG; ++i)
 		t->sighand->action[i].sa.sa_handler = SIG_IGN;
 	flush_signals(t);
 }
 /*
  * Flush all handlers for a task.
  */
 void
 flush_signal_handlers(struct task_struct *t, int force_default)
 {
 	int i;
 	struct k_sigaction *ka = &t->sighand->action[0];
 	for (i = _NSIG ; i != 0 ; i--) {
 		if (force_default || ka->sa.sa_handler != SIG_IGN)
 			ka->sa.sa_handler = SIG_DFL;
 		ka->sa.sa_flags = 0;
 		sigemptyset(&ka->sa.sa_mask);
 		ka++;
 	}
 }
 int unhandled_signal(struct task_struct *tsk, int sig)
 {
 	void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
 	if (is_global_init(tsk))
 		return 1;
 	if (handler != SIG_IGN && handler != SIG_DFL)
 		return 0;
 	/* if ptraced, let the tracer determine */
 	return !tsk->ptrace;
 }
 /*
  * Notify the system that a driver wants to block all signals for this
  * process, and wants to be notified if any signals at all were to be
  * sent/acted upon.  If the notifier routine returns non-zero, then the
  * signal will be acted upon after all.  If the notifier routine returns 0,
  * then then signal will be blocked.  Only one block per process is
  * allowed.  priv is a pointer to private data that the notifier routine
  * can use to determine if the signal should be blocked or not.
  */
 void
 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&current->sighand->siglock, flags);
 	current->notifier_mask = mask;
 	current->notifier_data = priv;
 	current->notifier = notifier;
 	spin_unlock_irqrestore(&current->sighand->siglock, flags);
 }
 /* Notify the system that blocking has ended. */
 void
 unblock_all_signals(void)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&current->sighand->siglock, flags);
 	current->notifier = NULL;
 	current->notifier_data = NULL;
 	recalc_sigpending();
 	spin_unlock_irqrestore(&current->sighand->siglock, flags);
 }
 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
 {
 	struct sigqueue *q, *first = NULL;
 	/*
 	 * Collect the siginfo appropriate to this signal.  Check if
 	 * there is another siginfo for the same signal.
 	*/
 	list_for_each_entry(q, &list->list, list) {
 		if (q->info.si_signo == sig) {
 			if (first)
 				goto still_pending;
 			first = q;
 		}
 	}
 	sigdelset(&list->signal, sig);
 	if (first) {
 still_pending:
 		list_del_init(&first->list);
 		copy_siginfo(info, &first->info);
 		__sigqueue_free(first);
 	} else {
 		/*
 		 * Ok, it wasn't in the queue.  This must be
 		 * a fast-pathed signal or we must have been
 		 * out of queue space.  So zero out the info.
 		 */
 		info->si_signo = sig;
 		info->si_errno = 0;
 		info->si_code = SI_USER;
 		info->si_pid = 0;
 		info->si_uid = 0;
 	}
 }
 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
 			siginfo_t *info)
 {
 	int sig = next_signal(pending, mask);
 	if (sig) {
 		if (current->notifier) {
 			if (sigismember(current->notifier_mask, sig)) {
 				if (!(current->notifier)(current->notifier_data)) {
 					clear_thread_flag(TIF_SIGPENDING);
 					return 0;
 				}
 			}
 		}
 		collect_signal(sig, pending, info);
 	}
 	return sig;
 }
 /*
  * Dequeue a signal and return the element to the caller, which is
  * expected to free it.
  *
  * All callers have to hold the siglock.
  */
 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
 {
 	int signr;
 	/* We only dequeue private signals from ourselves, we don't let
 	 * signalfd steal them
 	 */
 	signr = __dequeue_signal(&tsk->pending, mask, info);
 	if (!signr) {
 		signr = __dequeue_signal(&tsk->signal->shared_pending,
 					 mask, info);
 		/*
 		 * itimer signal ?
 		 *
 		 * itimers are process shared and we restart periodic
 		 * itimers in the signal delivery path to prevent DoS
 		 * attacks in the high resolution timer case. This is
 		 * compliant with the old way of self-restarting
 		 * itimers, as the SIGALRM is a legacy signal and only
 		 * queued once. Changing the restart behaviour to
 		 * restart the timer in the signal dequeue path is
 		 * reducing the timer noise on heavy loaded !highres
 		 * systems too.
 		 */
 		if (unlikely(signr == SIGALRM)) {
 			struct hrtimer *tmr = &tsk->signal->real_timer;
 			if (!hrtimer_is_queued(tmr) &&
 			    tsk->signal->it_real_incr.tv64 != 0) {
 				hrtimer_forward(tmr, tmr->base->get_time(),
 						tsk->signal->it_real_incr);
 				hrtimer_restart(tmr);
 			}
 		}
 	}
 	recalc_sigpending();
 	if (!signr)
 		return 0;
 	if (unlikely(sig_kernel_stop(signr))) {
 		/*
 		 * Set a marker that we have dequeued a stop signal.  Our
 		 * caller might release the siglock and then the pending
 		 * stop signal it is about to process is no longer in the
 		 * pending bitmasks, but must still be cleared by a SIGCONT
 		 * (and overruled by a SIGKILL).  So those cases clear this
 		 * shared flag after we've set it.  Note that this flag may
 		 * remain set after the signal we return is ignored or
 		 * handled.  That doesn't matter because its only purpose
 		 * is to alert stop-signal processing code when another
 		 * processor has come along and cleared the flag.
 		 */
 		current->jobctl |= JOBCTL_STOP_DEQUEUED;
 	}
 	if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
 		/*
 		 * Release the siglock to ensure proper locking order
 		 * of timer locks outside of siglocks.  Note, we leave
 		 * irqs disabled here, since the posix-timers code is
 		 * about to disable them again anyway.
 		 */
 		spin_unlock(&tsk->sighand->siglock);
 		do_schedule_next_timer(info);
 		spin_lock(&tsk->sighand->siglock);
 	}
 	return signr;
 }
 /*
  * Tell a process that it has a new active signal..
  *
  * NOTE! we rely on the previous spin_lock to
  * lock interrupts for us! We can only be called with
  * "siglock" held, and the local interrupt must
  * have been disabled when that got acquired!
  *
  * No need to set need_resched since signal event passing
  * goes through ->blocked
  */
 void signal_wake_up(struct task_struct *t, int resume)
 {
 	unsigned int mask;
 	set_tsk_thread_flag(t, TIF_SIGPENDING);
 	/*
 	 * For SIGKILL, we want to wake it up in the stopped/traced/killable
 	 * case. We don't check t->state here because there is a race with it
 	 * executing another processor and just now entering stopped state.
 	 * By using wake_up_state, we ensure the process will wake up and
 	 * handle its death signal.
 	 */
 	mask = TASK_INTERRUPTIBLE;
 	if (resume)
 		mask |= TASK_WAKEKILL;
 	if (!wake_up_state(t, mask))
 		kick_process(t);
 }
 /*
  * Remove signals in mask from the pending set and queue.
  * Returns 1 if any signals were found.
  *
  * All callers must be holding the siglock.
  *
  * This version takes a sigset mask and looks at all signals,
  * not just those in the first mask word.
  */
 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
 {
 	struct sigqueue *q, *n;
 	sigset_t m;
 	sigandsets(&m, mask, &s->signal);
 	if (sigisemptyset(&m))
 		return 0;
 	sigandnsets(&s->signal, &s->signal, mask);
 	list_for_each_entry_safe(q, n, &s->list, list) {
 		if (sigismember(mask, q->info.si_signo)) {
 			list_del_init(&q->list);
 			__sigqueue_free(q);
 		}
 	}
 	return 1;
 }
 /*
  * Remove signals in mask from the pending set and queue.
  * Returns 1 if any signals were found.
  *
  * All callers must be holding the siglock.
  */
 static int rm_from_queue(unsigned long mask, struct sigpending *s)
 {
 	struct sigqueue *q, *n;
 	if (!sigtestsetmask(&s->signal, mask))
 		return 0;
 	sigdelsetmask(&s->signal, mask);
 	list_for_each_entry_safe(q, n, &s->list, list) {
 		if (q->info.si_signo < SIGRTMIN &&
 		    (mask & sigmask(q->info.si_signo))) {
 			list_del_init(&q->list);
 			__sigqueue_free(q);
 		}
 	}
 	return 1;
 }
 static inline int is_si_special(const struct siginfo *info)
 {
 	return info <= SEND_SIG_FORCED;
 }
 static inline bool si_fromuser(const struct siginfo *info)
 {
 	return info == SEND_SIG_NOINFO ||
 		(!is_si_special(info) && SI_FROMUSER(info));
 }
 /*
  * called with RCU read lock from check_kill_permission()
  */
 static int kill_ok_by_cred(struct task_struct *t)
 {
 	const struct cred *cred = current_cred();
 	const struct cred *tcred = __task_cred(t);
 	if (uid_eq(cred->euid, tcred->suid) ||
 	    uid_eq(cred->euid, tcred->uid)  ||
 	    uid_eq(cred->uid,  tcred->suid) ||
 	    uid_eq(cred->uid,  tcred->uid))
 		return 1;
 	if (ns_capable(tcred->user_ns, CAP_KILL))
 		return 1;
 	return 0;
 }
 /*
  * Bad permissions for sending the signal
  * - the caller must hold the RCU read lock
  */
 static int check_kill_permission(int sig, struct siginfo *info,
 				 struct task_struct *t)
 {
 	struct pid *sid;
 	int error;
 	if (!valid_signal(sig))
 		return -EINVAL;
 	if (!si_fromuser(info))
 		return 0;
 	error = audit_signal_info(sig, t); /* Let audit system see the signal */
 	if (error)
 		return error;
 	if (!same_thread_group(current, t) &&
 	    !kill_ok_by_cred(t)) {
 		switch (sig) {
 		case SIGCONT:
 			sid = task_session(t);
 			/*
 			 * We don't return the error if sid == NULL. The
 			 * task was unhashed, the caller must notice this.
 			 */
 			if (!sid || sid == task_session(current))
 				break;
 		default:
 			return -EPERM;
 		}
 	}
 	return security_task_kill(t, info, sig, 0);
 }
 /**
  * ptrace_trap_notify - schedule trap to notify ptracer
  * @t: tracee wanting to notify tracer
  *
  * This function schedules sticky ptrace trap which is cleared on the next
  * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
  * ptracer.
  *
  * If @t is running, STOP trap will be taken.  If trapped for STOP and
  * ptracer is listening for events, tracee is woken up so that it can
  * re-trap for the new event.  If trapped otherwise, STOP trap will be
  * eventually taken without returning to userland after the existing traps
  * are finished by PTRACE_CONT.
  *
  * CONTEXT:
  * Must be called with @task->sighand->siglock held.
  */
 static void ptrace_trap_notify(struct task_struct *t)
 {
 	WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
 	assert_spin_locked(&t->sighand->siglock);
 	task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
 	signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
 }
 /*
  * Handle magic process-wide effects of stop/continue signals. Unlike
  * the signal actions, these happen immediately at signal-generation
  * time regardless of blocking, ignoring, or handling.  This does the
  * actual continuing for SIGCONT, but not the actual stopping for stop
  * signals. The process stop is done as a signal action for SIG_DFL.
  *
  * Returns true if the signal should be actually delivered, otherwise
  * it should be dropped.
  */
 static int prepare_signal(int sig, struct task_struct *p, bool force)
 {
 	struct signal_struct *signal = p->signal;
 	struct task_struct *t;
 	if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
 		/*
 		 * The process is in the middle of dying, nothing to do.
 		 */
 	} else if (sig_kernel_stop(sig)) {
 		/*
 		 * This is a stop signal.  Remove SIGCONT from all queues.
 		 */
 		rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
 		t = p;
 		do {
 			rm_from_queue(sigmask(SIGCONT), &t->pending);
 		} while_each_thread(p, t);
 	} else if (sig == SIGCONT) {
 		unsigned int why;
 		/*
 		 * Remove all stop signals from all queues, wake all threads.
 		 */
 		rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
 		t = p;
 		do {
 			task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
 			rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
 			if (likely(!(t->ptrace & PT_SEIZED)))
 				wake_up_state(t, __TASK_STOPPED);
 			else
 				ptrace_trap_notify(t);
 		} while_each_thread(p, t);
 		/*
 		 * Notify the parent with CLD_CONTINUED if we were stopped.
 		 *
 		 * If we were in the middle of a group stop, we pretend it
 		 * was already finished, and then continued. Since SIGCHLD
 		 * doesn't queue we report only CLD_STOPPED, as if the next
 		 * CLD_CONTINUED was dropped.
 		 */
 		why = 0;
 		if (signal->flags & SIGNAL_STOP_STOPPED)
 			why |= SIGNAL_CLD_CONTINUED;
 		else if (signal->group_stop_count)
 			why |= SIGNAL_CLD_STOPPED;
 		if (why) {
 			/*
 			 * The first thread which returns from do_signal_stop()
 			 * will take ->siglock, notice SIGNAL_CLD_MASK, and
 			 * notify its parent. See get_signal_to_deliver().
 			 */
 			signal->flags = why | SIGNAL_STOP_CONTINUED;
 			signal->group_stop_count = 0;
 			signal->group_exit_code = 0;
 		}
 	}
 	return !sig_ignored(p, sig, force);
 }
 /*
  * Test if P wants to take SIG.  After we've checked all threads with this,
  * it's equivalent to finding no threads not blocking SIG.  Any threads not
  * blocking SIG were ruled out because they are not running and already
  * have pending signals.  Such threads will dequeue from the shared queue
  * as soon as they're available, so putting the signal on the shared queue
  * will be equivalent to sending it to one such thread.
  */
 static inline int wants_signal(int sig, struct task_struct *p)
 {
 	if (sigismember(&p->blocked, sig))
 		return 0;
 	if (p->flags & PF_EXITING)
 		return 0;
 	if (sig == SIGKILL)
 		return 1;
 	if (task_is_stopped_or_traced(p))
 		return 0;
 	return task_curr(p) || !signal_pending(p);
 }
 static void complete_signal(int sig, struct task_struct *p, int group)
 {
 	struct signal_struct *signal = p->signal;
 	struct task_struct *t;
 	/*
 	 * Now find a thread we can wake up to take the signal off the queue.
 	 *
 	 * If the main thread wants the signal, it gets first crack.
 	 * Probably the least surprising to the average bear.
 	 */
 	if (wants_signal(sig, p))
 		t = p;
 	else if (!group || thread_group_empty(p))
 		/*
 		 * There is just one thread and it does not need to be woken.
 		 * It will dequeue unblocked signals before it runs again.
 		 */
 		return;
 	else {
 		/*
 		 * Otherwise try to find a suitable thread.
 		 */
 		t = signal->curr_target;
 		while (!wants_signal(sig, t)) {
 			t = next_thread(t);
 			if (t == signal->curr_target)
 				/*
 				 * No thread needs to be woken.
 				 * Any eligible threads will see
 				 * the signal in the queue soon.
 				 */
 				return;
 		}
 		signal->curr_target = t;
 	}
 	/*
 	 * Found a killable thread.  If the signal will be fatal,
 	 * then start taking the whole group down immediately.
 	 */
 	if (sig_fatal(p, sig) &&
 	    !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
 	    !sigismember(&t->real_blocked, sig) &&
 	    (sig == SIGKILL || !t->ptrace)) {
 		/*
 		 * This signal will be fatal to the whole group.
 		 */
 		if (!sig_kernel_coredump(sig)) {
 			/*
 			 * Start a group exit and wake everybody up.
 			 * This way we don't have other threads
 			 * running and doing things after a slower
 			 * thread has the fatal signal pending.
 			 */
 			signal->flags = SIGNAL_GROUP_EXIT;
 			signal->group_exit_code = sig;
 			signal->group_stop_count = 0;
 			t = p;
 			do {
 				task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
 				sigaddset(&t->pending.signal, SIGKILL);
 				signal_wake_up(t, 1);
 			} while_each_thread(p, t);
 			return;
 		}
 	}
 	/*
 	 * The signal is already in the shared-pending queue.
 	 * Tell the chosen thread to wake up and dequeue it.
 	 */
 	signal_wake_up(t, sig == SIGKILL);
 	return;
 }
 static inline int legacy_queue(struct sigpending *signals, int sig)
 {
 	return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
 }
 #ifdef CONFIG_USER_NS
 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
 {
 	if (current_user_ns() == task_cred_xxx(t, user_ns))
 		return;
 	if (SI_FROMKERNEL(info))
 		return;
 	rcu_read_lock();
 	info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
 					make_kuid(current_user_ns(), info->si_uid));
 	rcu_read_unlock();
 }
 #else
 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
 {
 	return;
 }
 #endif
 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
 			int group, int from_ancestor_ns)
 {
 	struct sigpending *pending;
 	struct sigqueue *q;
 	int override_rlimit;
 	int ret = 0, result;
 	assert_spin_locked(&t->sighand->siglock);
 	result = TRACE_SIGNAL_IGNORED;
 	if (!prepare_signal(sig, t,
 			from_ancestor_ns || (info == SEND_SIG_FORCED)))
 		goto ret;
 	pending = group ? &t->signal->shared_pending : &t->pending;
 	/*
 	 * Short-circuit ignored signals and support queuing
 	 * exactly one non-rt signal, so that we can get more
 	 * detailed information about the cause of the signal.
 	 */
 	result = TRACE_SIGNAL_ALREADY_PENDING;
 	if (legacy_queue(pending, sig))
 		goto ret;
 	result = TRACE_SIGNAL_DELIVERED;
 	/*
 	 * fast-pathed signals for kernel-internal things like SIGSTOP
 	 * or SIGKILL.
 	 */
 	if (info == SEND_SIG_FORCED)
 		goto out_set;
 	/*
 	 * Real-time signals must be queued if sent by sigqueue, or
 	 * some other real-time mechanism.  It is implementation
 	 * defined whether kill() does so.  We attempt to do so, on
 	 * the principle of least surprise, but since kill is not
 	 * allowed to fail with EAGAIN when low on memory we just
 	 * make sure at least one signal gets delivered and don't
 	 * pass on the info struct.
 	 */
 	if (sig < SIGRTMIN)
 		override_rlimit = (is_si_special(info) || info->si_code >= 0);
 	else
 		override_rlimit = 0;
 	q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
 		override_rlimit);
 	if (q) {
 		list_add_tail(&q->list, &pending->list);
 		switch ((unsigned long) info) {
 		case (unsigned long) SEND_SIG_NOINFO:
 			q->info.si_signo = sig;
 			q->info.si_errno = 0;
 			q->info.si_code = SI_USER;
 			q->info.si_pid = task_tgid_nr_ns(current,
 							task_active_pid_ns(t));
 			q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
 			break;
 		case (unsigned long) SEND_SIG_PRIV:
 			q->info.si_signo = sig;
 			q->info.si_errno = 0;
 			q->info.si_code = SI_KERNEL;
 			q->info.si_pid = 0;
 			q->info.si_uid = 0;
 			break;
 		default:
 			copy_siginfo(&q->info, info);
 			if (from_ancestor_ns)
 				q->info.si_pid = 0;
 			break;
 		}
 		userns_fixup_signal_uid(&q->info, t);
 	} else if (!is_si_special(info)) {
 		if (sig >= SIGRTMIN && info->si_code != SI_USER) {
 			/*
 			 * Queue overflow, abort.  We may abort if the
 			 * signal was rt and sent by user using something
 			 * other than kill().
 			 */
 			result = TRACE_SIGNAL_OVERFLOW_FAIL;
 			ret = -EAGAIN;
 			goto ret;
 		} else {
 			/*
 			 * This is a silent loss of information.  We still
 			 * send the signal, but the *info bits are lost.
 			 */
 			result = TRACE_SIGNAL_LOSE_INFO;
 		}
 	}
 out_set:
 	signalfd_notify(t, sig);
 	sigaddset(&pending->signal, sig);
 	complete_signal(sig, t, group);
 ret:
 	trace_signal_generate(sig, info, t, group, result);
 	return ret;
 }
 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
 			int group)
 {
 	int from_ancestor_ns = 0;
 #ifdef CONFIG_PID_NS
 	from_ancestor_ns = si_fromuser(info) &&
 			   !task_pid_nr_ns(current, task_active_pid_ns(t));
 #endif
 	return __send_signal(sig, info, t, group, from_ancestor_ns);
 }
 static void print_fatal_signal(int signr)
 {
 	struct pt_regs *regs = signal_pt_regs();
 	printk("%s/%d: potentially unexpected fatal signal %d.\n",
 		current->comm, task_pid_nr(current), signr);
 #if defined(__i386__) && !defined(__arch_um__)
 	printk("code at %08lx: ", regs->ip);
 	{
 		int i;
 		for (i = 0; i < 16; i++) {
 			unsigned char insn;
 			if (get_user(insn, (unsigned char *)(regs->ip + i)))
 				break;
 			printk("%02x ", insn);
 		}
 	}
 #endif
 	printk("\n");
 	preempt_disable();
 	show_regs(regs);
 	preempt_enable();
 }
 static int __init setup_print_fatal_signals(char *str)
 {
 	get_option (&str, &print_fatal_signals);
 	return 1;
 }
 __setup("print-fatal-signals=", setup_print_fatal_signals);
 int
 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
 {
 	return send_signal(sig, info, p, 1);
 }
 static int
 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
 {
 	return send_signal(sig, info, t, 0);
 }
 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
 			bool group)
 {
 	unsigned long flags;
 	int ret = -ESRCH;
 	if (lock_task_sighand(p, &flags)) {
 		ret = send_signal(sig, info, p, group);
 		unlock_task_sighand(p, &flags);
 	}
 	return ret;
 }
 /*
  * Force a signal that the process can't ignore: if necessary
  * we unblock the signal and change any SIG_IGN to SIG_DFL.
  *
  * Note: If we unblock the signal, we always reset it to SIG_DFL,
  * since we do not want to have a signal handler that was blocked
  * be invoked when user space had explicitly blocked it.
  *
  * We don't want to have recursive SIGSEGV's etc, for example,
  * that is why we also clear SIGNAL_UNKILLABLE.
  */
 int
 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
 {
 	unsigned long int flags;
 	int ret, blocked, ignored;
 	struct k_sigaction *action;
 	spin_lock_irqsave(&t->sighand->siglock, flags);
 	action = &t->sighand->action[sig-1];
 	ignored = action->sa.sa_handler == SIG_IGN;
 	blocked = sigismember(&t->blocked, sig);
 	if (blocked || ignored) {
 		action->sa.sa_handler = SIG_DFL;
 		if (blocked) {
 			sigdelset(&t->blocked, sig);
 			recalc_sigpending_and_wake(t);
 		}
 	}
 	if (action->sa.sa_handler == SIG_DFL)
 		t->signal->flags &= ~SIGNAL_UNKILLABLE;
 	ret = specific_send_sig_info(sig, info, t);
 	spin_unlock_irqrestore(&t->sighand->siglock, flags);
 	return ret;
 }
 /*
  * Nuke all other threads in the group.
  */
 int zap_other_threads(struct task_struct *p)
 {
 	struct task_struct *t = p;
 	int count = 0;
 	p->signal->group_stop_count = 0;
 	while_each_thread(p, t) {
 		task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
 		count++;
 		/* Don't bother with already dead threads */
 		if (t->exit_state)
 			continue;
 		sigaddset(&t->pending.signal, SIGKILL);
 		signal_wake_up(t, 1);
 	}
 	return count;
 }
 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
 					   unsigned long *flags)
 {
 	struct sighand_struct *sighand;
 	for (;;) {
 		local_irq_save(*flags);
 		rcu_read_lock();
 		sighand = rcu_dereference(tsk->sighand);
 		if (unlikely(sighand == NULL)) {
 			rcu_read_unlock();
 			local_irq_restore(*flags);
 			break;
 		}
 		spin_lock(&sighand->siglock);
 		if (likely(sighand == tsk->sighand)) {
 			rcu_read_unlock();
 			break;
 		}
 		spin_unlock(&sighand->siglock);
 		rcu_read_unlock();
 		local_irq_restore(*flags);
 	}
 	return sighand;
 }
 /*
  * send signal info to all the members of a group
  */
 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
 {
 	int ret;
 	rcu_read_lock();
 	ret = check_kill_permission(sig, info, p);
 	rcu_read_unlock();
 	if (!ret && sig)
 		ret = do_send_sig_info(sig, info, p, true);
 	return ret;
 }
 /*
  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
  * control characters do (^C, ^Z etc)
  * - the caller must hold at least a readlock on tasklist_lock
  */
 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
 {
 	struct task_struct *p = NULL;
 	int retval, success;
 	success = 0;
 	retval = -ESRCH;
 	do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
 		int err = group_send_sig_info(sig, info, p);
 		success |= !err;
 		retval = err;
 	} while_each_pid_task(pgrp, PIDTYPE_PGID, p);
 	return success ? 0 : retval;
 }
 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
 {
 	int error = -ESRCH;
 	struct task_struct *p;
 	rcu_read_lock();
 retry:
 	p = pid_task(pid, PIDTYPE_PID);
 	if (p) {
 		error = group_send_sig_info(sig, info, p);
 		if (unlikely(error == -ESRCH))
 			/*
 			 * The task was unhashed in between, try again.
 			 * If it is dead, pid_task() will return NULL,
 			 * if we race with de_thread() it will find the
 			 * new leader.
 			 */
 			goto retry;
 	}
 	rcu_read_unlock();
 	return error;
 }
 int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
 {
 	int error;
 	rcu_read_lock();
 	error = kill_pid_info(sig, info, find_vpid(pid));
 	rcu_read_unlock();
 	return error;
 }
 static int kill_as_cred_perm(const struct cred *cred,
 			     struct task_struct *target)
 {
 	const struct cred *pcred = __task_cred(target);
 	if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
 	    !uid_eq(cred->uid,  pcred->suid) && !uid_eq(cred->uid,  pcred->uid))
 		return 0;
 	return 1;
 }
 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
 			 const struct cred *cred, u32 secid)
 {
 	int ret = -EINVAL;
 	struct task_struct *p;
 	unsigned long flags;
 	if (!valid_signal(sig))
 		return ret;
 	rcu_read_lock();
 	p = pid_task(pid, PIDTYPE_PID);
 	if (!p) {
 		ret = -ESRCH;
 		goto out_unlock;
 	}
 	if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
 		ret = -EPERM;
 		goto out_unlock;
 	}
 	ret = security_task_kill(p, info, sig, secid);
 	if (ret)
 		goto out_unlock;
 	if (sig) {
 		if (lock_task_sighand(p, &flags)) {
 			ret = __send_signal(sig, info, p, 1, 0);
 			unlock_task_sighand(p, &flags);
 		} else
 			ret = -ESRCH;
 	}
 out_unlock:
 	rcu_read_unlock();
 	return ret;
 }
 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
 /*
  * kill_something_info() interprets pid in interesting ways just like kill(2).
  *
  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
  * is probably wrong.  Should make it like BSD or SYSV.
  */
 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
 {
 	int ret;
 	if (pid > 0) {
 		rcu_read_lock();
 		ret = kill_pid_info(sig, info, find_vpid(pid));
 		rcu_read_unlock();
 		return ret;
 	}
 	read_lock(&tasklist_lock);
 	if (pid != -1) {
 		ret = __kill_pgrp_info(sig, info,
 				pid ? find_vpid(-pid) : task_pgrp(current));
 	} else {
 		int retval = 0, count = 0;
 		struct task_struct * p;
 		for_each_process(p) {
 			if (task_pid_vnr(p) > 1 &&
 					!same_thread_group(p, current)) {
 				int err = group_send_sig_info(sig, info, p);
 				++count;
 				if (err != -EPERM)
 					retval = err;
 			}
 		}
 		ret = count ? retval : -ESRCH;
 	}
 	read_unlock(&tasklist_lock);
 	return ret;
 }
 /*
  * These are for backward compatibility with the rest of the kernel source.
  */
 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
 {
 	/*
 	 * Make sure legacy kernel users don't send in bad values
 	 * (normal paths check this in check_kill_permission).
 	 */
 	if (!valid_signal(sig))
 		return -EINVAL;
 	return do_send_sig_info(sig, info, p, false);
 }
 #define __si_special(priv) \
 	((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
 int
 send_sig(int sig, struct task_struct *p, int priv)
 {
 	return send_sig_info(sig, __si_special(priv), p);
 }
 void
 force_sig(int sig, struct task_struct *p)
 {
 	force_sig_info(sig, SEND_SIG_PRIV, p);
 }
 /*
  * When things go south during signal handling, we
  * will force a SIGSEGV. And if the signal that caused
  * the problem was already a SIGSEGV, we'll want to
  * make sure we don't even try to deliver the signal..
  */
 int
 force_sigsegv(int sig, struct task_struct *p)
 {
 	if (sig == SIGSEGV) {
 		unsigned long flags;
 		spin_lock_irqsave(&p->sighand->siglock, flags);
 		p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
 		spin_unlock_irqrestore(&p->sighand->siglock, flags);
 	}
 	force_sig(SIGSEGV, p);
 	return 0;
 }
 int kill_pgrp(struct pid *pid, int sig, int priv)
 {
 	int ret;
 	read_lock(&tasklist_lock);
 	ret = __kill_pgrp_info(sig, __si_special(priv), pid);
 	read_unlock(&tasklist_lock);
 	return ret;
 }
 EXPORT_SYMBOL(kill_pgrp);
 int kill_pid(struct pid *pid, int sig, int priv)
 {
 	return kill_pid_info(sig, __si_special(priv), pid);
 }
 EXPORT_SYMBOL(kill_pid);
 /*
  * These functions support sending signals using preallocated sigqueue
  * structures.  This is needed "because realtime applications cannot
  * afford to lose notifications of asynchronous events, like timer
  * expirations or I/O completions".  In the case of POSIX Timers
  * we allocate the sigqueue structure from the timer_create.  If this
  * allocation fails we are able to report the failure to the application
  * with an EAGAIN error.
  */
 struct sigqueue *sigqueue_alloc(void)
 {
 	struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
 	if (q)
 		q->flags |= SIGQUEUE_PREALLOC;
 	return q;
 }
 void sigqueue_free(struct sigqueue *q)
 {
 	unsigned long flags;
 	spinlock_t *lock = &current->sighand->siglock;
 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
 	/*
 	 * We must hold ->siglock while testing q->list
 	 * to serialize with collect_signal() or with
 	 * __exit_signal()->flush_sigqueue().
 	 */
 	spin_lock_irqsave(lock, flags);
 	q->flags &= ~SIGQUEUE_PREALLOC;
 	/*
 	 * If it is queued it will be freed when dequeued,
 	 * like the "regular" sigqueue.
 	 */
 	if (!list_empty(&q->list))
 		q = NULL;
 	spin_unlock_irqrestore(lock, flags);
 	if (q)
 		__sigqueue_free(q);
 }
 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
 {
 	int sig = q->info.si_signo;
 	struct sigpending *pending;
 	unsigned long flags;
 	int ret, result;
 	BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
 	ret = -1;
 	if (!likely(lock_task_sighand(t, &flags)))
 		goto ret;
 	ret = 1; /* the signal is ignored */
 	result = TRACE_SIGNAL_IGNORED;
 	if (!prepare_signal(sig, t, false))
 		goto out;
 	ret = 0;
 	if (unlikely(!list_empty(&q->list))) {
 		/*
 		 * If an SI_TIMER entry is already queue just increment
 		 * the overrun count.
 		 */
 		BUG_ON(q->info.si_code != SI_TIMER);
 		q->info.si_overrun++;
 		result = TRACE_SIGNAL_ALREADY_PENDING;
 		goto out;
 	}
 	q->info.si_overrun = 0;
 	signalfd_notify(t, sig);
 	pending = group ? &t->signal->shared_pending : &t->pending;
 	list_add_tail(&q->list, &pending->list);
 	sigaddset(&pending->signal, sig);
 	complete_signal(sig, t, group);
 	result = TRACE_SIGNAL_DELIVERED;
 out:
 	trace_signal_generate(sig, &q->info, t, group, result);
 	unlock_task_sighand(t, &flags);
 ret:
 	return ret;
 }
 /*
  * Let a parent know about the death of a child.
  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
  *
  * Returns true if our parent ignored us and so we've switched to
  * self-reaping.
  */
 bool do_notify_parent(struct task_struct *tsk, int sig)
 {
 	struct siginfo info;
 	unsigned long flags;
 	struct sighand_struct *psig;
 	bool autoreap = false;
 	BUG_ON(sig == -1);
  	/* do_notify_parent_cldstop should have been called instead.  */
  	BUG_ON(task_is_stopped_or_traced(tsk));
 	BUG_ON(!tsk->ptrace &&
 	       (tsk->group_leader != tsk || !thread_group_empty(tsk)));
 	if (sig != SIGCHLD) {
 		/*
 		 * This is only possible if parent == real_parent.
 		 * Check if it has changed security domain.
 		 */
 		if (tsk->parent_exec_id != tsk->parent->self_exec_id)
 			sig = SIGCHLD;
 	}
 	info.si_signo = sig;
 	info.si_errno = 0;
 	/*
 	 * We are under tasklist_lock here so our parent is tied to
 	 * us and cannot change.
 	 *
 	 * task_active_pid_ns will always return the same pid namespace
 	 * until a task passes through release_task.
 	 *
 	 * write_lock() currently calls preempt_disable() which is the
 	 * same as rcu_read_lock(), but according to Oleg, this is not
 	 * correct to rely on this
 	 */
 	rcu_read_lock();
 	info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
 	info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
 				       task_uid(tsk));
 	rcu_read_unlock();
 	info.si_utime = cputime_to_clock_t(tsk->utime + tsk->signal->utime);
 	info.si_stime = cputime_to_clock_t(tsk->stime + tsk->signal->stime);
 	info.si_status = tsk->exit_code & 0x7f;
 	if (tsk->exit_code & 0x80)
 		info.si_code = CLD_DUMPED;
 	else if (tsk->exit_code & 0x7f)
 		info.si_code = CLD_KILLED;
 	else {
 		info.si_code = CLD_EXITED;
 		info.si_status = tsk->exit_code >> 8;
 	}
 	psig = tsk->parent->sighand;
 	spin_lock_irqsave(&psig->siglock, flags);
 	if (!tsk->ptrace && sig == SIGCHLD &&
 	    (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
 	     (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
 		/*
 		 * We are exiting and our parent doesn't care.  POSIX.1
 		 * defines special semantics for setting SIGCHLD to SIG_IGN
 		 * or setting the SA_NOCLDWAIT flag: we should be reaped
 		 * automatically and not left for our parent's wait4 call.
 		 * Rather than having the parent do it as a magic kind of
 		 * signal handler, we just set this to tell do_exit that we
 		 * can be cleaned up without becoming a zombie.  Note that
 		 * we still call __wake_up_parent in this case, because a
 		 * blocked sys_wait4 might now return -ECHILD.
 		 *
 		 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
 		 * is implementation-defined: we do (if you don't want
 		 * it, just use SIG_IGN instead).
 		 */
 		autoreap = true;
 		if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
 			sig = 0;
 	}
 	if (valid_signal(sig) && sig)
 		__group_send_sig_info(sig, &info, tsk->parent);
 	__wake_up_parent(tsk, tsk->parent);
 	spin_unlock_irqrestore(&psig->siglock, flags);
 	return autoreap;
 }
 /**
  * do_notify_parent_cldstop - notify parent of stopped/continued state change
  * @tsk: task reporting the state change
  * @for_ptracer: the notification is for ptracer
  * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
  *
  * Notify @tsk's parent that the stopped/continued state has changed.  If
  * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
  * If %true, @tsk reports to @tsk->parent which should be the ptracer.
  *
  * CONTEXT:
  * Must be called with tasklist_lock at least read locked.
  */
 static void do_notify_parent_cldstop(struct task_struct *tsk,
 				     bool for_ptracer, int why)
 {
 	struct siginfo info;
 	unsigned long flags;
 	struct task_struct *parent;
 	struct sighand_struct *sighand;
 	if (for_ptracer) {
 		parent = tsk->parent;
 	} else {
 		tsk = tsk->group_leader;
 		parent = tsk->real_parent;
 	}
 	info.si_signo = SIGCHLD;
 	info.si_errno = 0;
 	/*
 	 * see comment in do_notify_parent() about the following 4 lines
 	 */
 	rcu_read_lock();
 	info.si_pid = task_pid_nr_ns(tsk, parent->nsproxy->pid_ns);
 	info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
 	rcu_read_unlock();
 	info.si_utime = cputime_to_clock_t(tsk->utime);
 	info.si_stime = cputime_to_clock_t(tsk->stime);
  	info.si_code = why;
  	switch (why) {
  	case CLD_CONTINUED:
  		info.si_status = SIGCONT;
  		break;
  	case CLD_STOPPED:
  		info.si_status = tsk->signal->group_exit_code & 0x7f;
  		break;
  	case CLD_TRAPPED:
  		info.si_status = tsk->exit_code & 0x7f;
  		break;
  	default:
  		BUG();
  	}
 	sighand = parent->sighand;
 	spin_lock_irqsave(&sighand->siglock, flags);
 	if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
 	    !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
 		__group_send_sig_info(SIGCHLD, &info, parent);
 	/*
 	 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
 	 */
 	__wake_up_parent(tsk, parent);
 	spin_unlock_irqrestore(&sighand->siglock, flags);
 }
 static inline int may_ptrace_stop(void)
 {
 	if (!likely(current->ptrace))
 		return 0;
 	/*
 	 * Are we in the middle of do_coredump?
 	 * If so and our tracer is also part of the coredump stopping
 	 * is a deadlock situation, and pointless because our tracer
 	 * is dead so don't allow us to stop.
 	 * If SIGKILL was already sent before the caller unlocked
 	 * ->siglock we must see ->core_state != NULL. Otherwise it
 	 * is safe to enter schedule().
 	 */
 	if (unlikely(current->mm->core_state) &&
 	    unlikely(current->mm == current->parent->mm))
 		return 0;
 	return 1;
 }
 /*
  * Return non-zero if there is a SIGKILL that should be waking us up.
  * Called with the siglock held.
  */
 static int sigkill_pending(struct task_struct *tsk)
 {
 	return	sigismember(&tsk->pending.signal, SIGKILL) ||
 		sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
 }
 /*
  * This must be called with current->sighand->siglock held.
  *
  * This should be the path for all ptrace stops.
  * We always set current->last_siginfo while stopped here.
  * That makes it a way to test a stopped process for
  * being ptrace-stopped vs being job-control-stopped.
  *
  * If we actually decide not to stop at all because the tracer
  * is gone, we keep current->exit_code unless clear_code.
  */
 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
 	__releases(&current->sighand->siglock)
 	__acquires(&current->sighand->siglock)
 {
 	bool gstop_done = false;
 	if (arch_ptrace_stop_needed(exit_code, info)) {
 		/*
 		 * The arch code has something special to do before a
 		 * ptrace stop.  This is allowed to block, e.g. for faults
 		 * on user stack pages.  We can't keep the siglock while
 		 * calling arch_ptrace_stop, so we must release it now.
 		 * To preserve proper semantics, we must do this before
 		 * any signal bookkeeping like checking group_stop_count.
 		 * Meanwhile, a SIGKILL could come in before we retake the
 		 * siglock.  That must prevent us from sleeping in TASK_TRACED.
 		 * So after regaining the lock, we must check for SIGKILL.
 		 */
 		spin_unlock_irq(&current->sighand->siglock);
 		arch_ptrace_stop(exit_code, info);
 		spin_lock_irq(&current->sighand->siglock);
 		if (sigkill_pending(current))
 			return;
 	}
 	/*
 	 * We're committing to trapping.  TRACED should be visible before
 	 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
 	 * Also, transition to TRACED and updates to ->jobctl should be
 	 * atomic with respect to siglock and should be done after the arch
 	 * hook as siglock is released and regrabbed across it.
 	 */
 	set_current_state(TASK_TRACED);
 	current->last_siginfo = info;
 	current->exit_code = exit_code;
 	/*
 	 * If @why is CLD_STOPPED, we're trapping to participate in a group
 	 * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
 	 * across siglock relocks since INTERRUPT was scheduled, PENDING
 	 * could be clear now.  We act as if SIGCONT is received after
 	 * TASK_TRACED is entered - ignore it.
 	 */
 	if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
 		gstop_done = task_participate_group_stop(current);
 	/* any trap clears pending STOP trap, STOP trap clears NOTIFY */
 	task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
 	if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
 		task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
 	/* entering a trap, clear TRAPPING */
 	task_clear_jobctl_trapping(current);
 	spin_unlock_irq(&current->sighand->siglock);
 	read_lock(&tasklist_lock);
 	if (may_ptrace_stop()) {
 		/*
 		 * Notify parents of the stop.
 		 *
 		 * While ptraced, there are two parents - the ptracer and
 		 * the real_parent of the group_leader.  The ptracer should
 		 * know about every stop while the real parent is only
 		 * interested in the completion of group stop.  The states
 		 * for the two don't interact with each other.  Notify
 		 * separately unless they're gonna be duplicates.
 		 */
 		do_notify_parent_cldstop(current, true, why);
 		if (gstop_done && ptrace_reparented(current))
 			do_notify_parent_cldstop(current, false, why);
 		/*
 		 * Don't want to allow preemption here, because
 		 * sys_ptrace() needs this task to be inactive.
 		 *
 		 * XXX: implement read_unlock_no_resched().
 		 */
 		preempt_disable();
 		read_unlock(&tasklist_lock);
 		preempt_enable_no_resched();
 		schedule();
 	} else {
 		/*
 		 * By the time we got the lock, our tracer went away.
 		 * Don't drop the lock yet, another tracer may come.
 		 *
 		 * If @gstop_done, the ptracer went away between group stop
 		 * completion and here.  During detach, it would have set
 		 * JOBCTL_STOP_PENDING on us and we'll re-enter
 		 * TASK_STOPPED in do_signal_stop() on return, so notifying
 		 * the real parent of the group stop completion is enough.
 		 */
 		if (gstop_done)
 			do_notify_parent_cldstop(current, false, why);
 		__set_current_state(TASK_RUNNING);
 		if (clear_code)
 			current->exit_code = 0;
 		read_unlock(&tasklist_lock);
 	}
 	/*
 	 * While in TASK_TRACED, we were considered "frozen enough".
 	 * Now that we woke up, it's crucial if we're supposed to be
 	 * frozen that we freeze now before running anything substantial.
 	 */
 	try_to_freeze();
 	/*
 	 * We are back.  Now reacquire the siglock before touching
 	 * last_siginfo, so that we are sure to have synchronized with
 	 * any signal-sending on another CPU that wants to examine it.
 	 */
 	spin_lock_irq(&current->sighand->siglock);
 	current->last_siginfo = NULL;
 	/* LISTENING can be set only during STOP traps, clear it */
 	current->jobctl &= ~JOBCTL_LISTENING;
 	/*
 	 * Queued signals ignored us while we were stopped for tracing.
 	 * So check for any that we should take before resuming user mode.
 	 * This sets TIF_SIGPENDING, but never clears it.
 	 */
 	recalc_sigpending_tsk(current);
 }
 static void ptrace_do_notify(int signr, int exit_code, int why)
 {
 	siginfo_t info;
 	memset(&info, 0, sizeof info);
 	info.si_signo = signr;
 	info.si_code = exit_code;
 	info.si_pid = task_pid_vnr(current);
 	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
 	/* Let the debugger run.  */
 	ptrace_stop(exit_code, why, 1, &info);
 }
 void ptrace_notify(int exit_code)
 {
 	BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
 	if (unlikely(current->task_works))
 		task_work_run();
 	spin_lock_irq(&current->sighand->siglock);
 	ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
 	spin_unlock_irq(&current->sighand->siglock);
 }
 /**
  * do_signal_stop - handle group stop for SIGSTOP and other stop signals
  * @signr: signr causing group stop if initiating
  *
  * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
  * and participate in it.  If already set, participate in the existing
  * group stop.  If participated in a group stop (and thus slept), %true is
  * returned with siglock released.
  *
  * If ptraced, this function doesn't handle stop itself.  Instead,
  * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
  * untouched.  The caller must ensure that INTERRUPT trap handling takes
  * places afterwards.
  *
  * CONTEXT:
  * Must be called with @current->sighand->siglock held, which is released
  * on %true return.
  *
  * RETURNS:
  * %false if group stop is already cancelled or ptrace trap is scheduled.
  * %true if participated in group stop.
  */
 static bool do_signal_stop(int signr)
 	__releases(&current->sighand->siglock)
 {
 	struct signal_struct *sig = current->signal;
 	if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
 		unsigned int gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
 		struct task_struct *t;
 		/* signr will be recorded in task->jobctl for retries */
 		WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
 		if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
 		    unlikely(signal_group_exit(sig)))
 			return false;
 		/*
 		 * There is no group stop already in progress.  We must
 		 * initiate one now.
 		 *
 		 * While ptraced, a task may be resumed while group stop is
 		 * still in effect and then receive a stop signal and
 		 * initiate another group stop.  This deviates from the
 		 * usual behavior as two consecutive stop signals can't
 		 * cause two group stops when !ptraced.  That is why we
 		 * also check !task_is_stopped(t) below.
 		 *
 		 * The condition can be distinguished by testing whether
 		 * SIGNAL_STOP_STOPPED is already set.  Don't generate
 		 * group_exit_code in such case.
 		 *
 		 * This is not necessary for SIGNAL_STOP_CONTINUED because
 		 * an intervening stop signal is required to cause two
 		 * continued events regardless of ptrace.
 		 */
 		if (!(sig->flags & SIGNAL_STOP_STOPPED))
 			sig->group_exit_code = signr;
 		sig->group_stop_count = 0;
 		if (task_set_jobctl_pending(current, signr | gstop))
 			sig->group_stop_count++;
 		for (t = next_thread(current); t != current;
 		     t = next_thread(t)) {
 			/*
 			 * Setting state to TASK_STOPPED for a group
 			 * stop is always done with the siglock held,
 			 * so this check has no races.
 			 */
 			if (!task_is_stopped(t) &&
 			    task_set_jobctl_pending(t, signr | gstop)) {
 				sig->group_stop_count++;
 				if (likely(!(t->ptrace & PT_SEIZED)))
 					signal_wake_up(t, 0);
 				else
 					ptrace_trap_notify(t);
 			}
 		}
 	}
 	if (likely(!current->ptrace)) {
 		int notify = 0;
 		/*
 		 * If there are no other threads in the group, or if there
 		 * is a group stop in progress and we are the last to stop,
 		 * report to the parent.
 		 */
 		if (task_participate_group_stop(current))
 			notify = CLD_STOPPED;
 		__set_current_state(TASK_STOPPED);
 		spin_unlock_irq(&current->sighand->siglock);
 		/*
 		 * Notify the parent of the group stop completion.  Because
 		 * we're not holding either the siglock or tasklist_lock
 		 * here, ptracer may attach inbetween; however, this is for
 		 * group stop and should always be delivered to the real
 		 * parent of the group leader.  The new ptracer will get
 		 * its notification when this task transitions into
 		 * TASK_TRACED.
 		 */
 		if (notify) {
 			read_lock(&tasklist_lock);
 			do_notify_parent_cldstop(current, false, notify);
 			read_unlock(&tasklist_lock);
 		}
 		/* Now we don't run again until woken by SIGCONT or SIGKILL */
 		schedule();
 		return true;
 	} else {
 		/*
 		 * While ptraced, group stop is handled by STOP trap.
 		 * Schedule it and let the caller deal with it.
 		 */
 		task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
 		return false;
 	}
 }
 /**
  * do_jobctl_trap - take care of ptrace jobctl traps
  *
  * When PT_SEIZED, it's used for both group stop and explicit
  * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
  * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
  * the stop signal; otherwise, %SIGTRAP.
  *
  * When !PT_SEIZED, it's used only for group stop trap with stop signal
  * number as exit_code and no siginfo.
  *
  * CONTEXT:
  * Must be called with @current->sighand->siglock held, which may be
  * released and re-acquired before returning with intervening sleep.
  */
 static void do_jobctl_trap(void)
 {
 	struct signal_struct *signal = current->signal;
 	int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
 	if (current->ptrace & PT_SEIZED) {
 		if (!signal->group_stop_count &&
 		    !(signal->flags & SIGNAL_STOP_STOPPED))
 			signr = SIGTRAP;
 		WARN_ON_ONCE(!signr);
 		ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
 				 CLD_STOPPED);
 	} else {
 		WARN_ON_ONCE(!signr);
 		ptrace_stop(signr, CLD_STOPPED, 0, NULL);
 		current->exit_code = 0;
 	}
 }
 static int ptrace_signal(int signr, siginfo_t *info)
 {
 	ptrace_signal_deliver();
 	/*
 	 * We do not check sig_kernel_stop(signr) but set this marker
 	 * unconditionally because we do not know whether debugger will
 	 * change signr. This flag has no meaning unless we are going
 	 * to stop after return from ptrace_stop(). In this case it will
 	 * be checked in do_signal_stop(), we should only stop if it was
 	 * not cleared by SIGCONT while we were sleeping. See also the
 	 * comment in dequeue_signal().
 	 */
 	current->jobctl |= JOBCTL_STOP_DEQUEUED;
 	ptrace_stop(signr, CLD_TRAPPED, 0, info);
 	/* We're back.  Did the debugger cancel the sig?  */
 	signr = current->exit_code;
 	if (signr == 0)
 		return signr;
 	current->exit_code = 0;
 	/*
 	 * Update the siginfo structure if the signal has
 	 * changed.  If the debugger wanted something
 	 * specific in the siginfo structure then it should
 	 * have updated *info via PTRACE_SETSIGINFO.
 	 */
 	if (signr != info->si_signo) {
 		info->si_signo = signr;
 		info->si_errno = 0;
 		info->si_code = SI_USER;
 		rcu_read_lock();
 		info->si_pid = task_pid_vnr(current->parent);
 		info->si_uid = from_kuid_munged(current_user_ns(),
 						task_uid(current->parent));
 		rcu_read_unlock();
 	}
 	/* If the (new) signal is now blocked, requeue it.  */
 	if (sigismember(&current->blocked, signr)) {
 		specific_send_sig_info(signr, info, current);
 		signr = 0;
 	}
 	return signr;
 }
 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
 			  struct pt_regs *regs, void *cookie)
 {
 	struct sighand_struct *sighand = current->sighand;
 	struct signal_struct *signal = current->signal;
 	int signr;
 	if (unlikely(current->task_works))
 		task_work_run();
 	if (unlikely(uprobe_deny_signal()))
 		return 0;
 relock:
 	/*
 	 * We'll jump back here after any time we were stopped in TASK_STOPPED.
 	 * While in TASK_STOPPED, we were considered "frozen enough".
 	 * Now that we woke up, it's crucial if we're supposed to be
 	 * frozen that we freeze now before running anything substantial.
 	 */
 	try_to_freeze();
 	spin_lock_irq(&sighand->siglock);
 	/*
 	 * Every stopped thread goes here after wakeup. Check to see if
 	 * we should notify the parent, prepare_signal(SIGCONT) encodes
 	 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
 	 */
 	if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
 		int why;
 		if (signal->flags & SIGNAL_CLD_CONTINUED)
 			why = CLD_CONTINUED;
 		else
 			why = CLD_STOPPED;
 		signal->flags &= ~SIGNAL_CLD_MASK;
 		spin_unlock_irq(&sighand->siglock);
 		/*
 		 * Notify the parent that we're continuing.  This event is
 		 * always per-process and doesn't make whole lot of sense
 		 * for ptracers, who shouldn't consume the state via
 		 * wait(2) either, but, for backward compatibility, notify
 		 * the ptracer of the group leader too unless it's gonna be
 		 * a duplicate.
 		 */
 		read_lock(&tasklist_lock);
 		do_notify_parent_cldstop(current, false, why);
 		if (ptrace_reparented(current->group_leader))
 			do_notify_parent_cldstop(current->group_leader,
 						true, why);
 		read_unlock(&tasklist_lock);
 		goto relock;
 	}
 	for (;;) {
 		struct k_sigaction *ka;
 		if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
 		    do_signal_stop(0))
 			goto relock;
 		if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
 			do_jobctl_trap();
 			spin_unlock_irq(&sighand->siglock);
 			goto relock;
 		}
 		signr = dequeue_signal(current, &current->blocked, info);
 		if (!signr)
 			break; /* will return 0 */
 		if (unlikely(current->ptrace) && signr != SIGKILL) {
 			signr = ptrace_signal(signr, info);
 			if (!signr)
 				continue;
 		}
 		ka = &sighand->action[signr-1];
 		/* Trace actually delivered signals. */
 		trace_signal_deliver(signr, info, ka);
 		if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
 			continue;
 		if (ka->sa.sa_handler != SIG_DFL) {
 			/* Run the handler.  */
 			*return_ka = *ka;
 			if (ka->sa.sa_flags & SA_ONESHOT)
 				ka->sa.sa_handler = SIG_DFL;
 			break; /* will return non-zero "signr" value */
 		}
 		/*
 		 * Now we are doing the default action for this signal.
 		 */
 		if (sig_kernel_ignore(signr)) /* Default is nothing. */
 			continue;
 		/*
 		 * Global init gets no signals it doesn't want.
 		 * Container-init gets no signals it doesn't want from same
 		 * container.
 		 *
 		 * Note that if global/container-init sees a sig_kernel_only()
 		 * signal here, the signal must have been generated internally
 		 * or must have come from an ancestor namespace. In either
 		 * case, the signal cannot be dropped.
 		 */
 		if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
 				!sig_kernel_only(signr))
 			continue;
 		if (sig_kernel_stop(signr)) {
 			/*
 			 * The default action is to stop all threads in
 			 * the thread group.  The job control signals
 			 * do nothing in an orphaned pgrp, but SIGSTOP
 			 * always works.  Note that siglock needs to be
 			 * dropped during the call to is_orphaned_pgrp()
 			 * because of lock ordering with tasklist_lock.
 			 * This allows an intervening SIGCONT to be posted.
 			 * We need to check for that and bail out if necessary.
 			 */
 			if (signr != SIGSTOP) {
 				spin_unlock_irq(&sighand->siglock);
 				/* signals can be posted during this window */
 				if (is_current_pgrp_orphaned())
 					goto relock;
 				spin_lock_irq(&sighand->siglock);
 			}
 			if (likely(do_signal_stop(info->si_signo))) {
 				/* It released the siglock.  */
 				goto relock;
 			}
 			/*
 			 * We didn't actually stop, due to a race
 			 * with SIGCONT or something like that.
 			 */
 			continue;
 		}
 		spin_unlock_irq(&sighand->siglock);
 		/*
 		 * Anything else is fatal, maybe with a core dump.
 		 */
 		current->flags |= PF_SIGNALED;
 		if (sig_kernel_coredump(signr)) {
 			if (print_fatal_signals)
 				print_fatal_signal(info->si_signo);
 			/*
 			 * If it was able to dump core, this kills all
 			 * other threads in the group and synchronizes with
 			 * their demise.  If we lost the race with another
 			 * thread getting here, it set group_exit_code
 			 * first and our do_group_exit call below will use
 			 * that value and ignore the one we pass it.
 			 */
 			do_coredump(info);
 		}
 		/*
 		 * Death signals, no core dump.
 		 */
 		do_group_exit(info->si_signo);
 		/* NOTREACHED */
 	}
 	spin_unlock_irq(&sighand->siglock);
 	return signr;
 }
 /**
  * signal_delivered -
  * @sig:		number of signal being delivered
  * @info:		siginfo_t of signal being delivered
  * @ka:			sigaction setting that chose the handler
  * @regs:		user register state
  * @stepping:		nonzero if debugger single-step or block-step in use
  *
  * This function should be called when a signal has succesfully been
  * delivered. It updates the blocked signals accordingly (@ka->sa.sa_mask
  * is always blocked, and the signal itself is blocked unless %SA_NODEFER
  * is set in @ka->sa.sa_flags.  Tracing is notified.
  */
 void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka,
 			struct pt_regs *regs, int stepping)
 {
 	sigset_t blocked;
 	/* 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.  */
 	clear_restore_sigmask();
 	sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
 	if (!(ka->sa.sa_flags & SA_NODEFER))
 		sigaddset(&blocked, sig);
 	set_current_blocked(&blocked);
 	tracehook_signal_handler(sig, info, ka, regs, stepping);
 }
 /*
  * It could be that complete_signal() picked us to notify about the
  * group-wide signal. Other threads should be notified now to take
  * the shared signals in @which since we will not.
  */
 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
 {
 	sigset_t retarget;
 	struct task_struct *t;
 	sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
 	if (sigisemptyset(&retarget))
 		return;
 	t = tsk;
 	while_each_thread(tsk, t) {
 		if (t->flags & PF_EXITING)
 			continue;
 		if (!has_pending_signals(&retarget, &t->blocked))
 			continue;
 		/* Remove the signals this thread can handle. */
 		sigandsets(&retarget, &retarget, &t->blocked);
 		if (!signal_pending(t))
 			signal_wake_up(t, 0);
 		if (sigisemptyset(&retarget))
 			break;
 	}
 }
 void exit_signals(struct task_struct *tsk)
 {
 	int group_stop = 0;
 	sigset_t unblocked;
 	/*
 	 * @tsk is about to have PF_EXITING set - lock out users which
 	 * expect stable threadgroup.
 	 */
 	threadgroup_change_begin(tsk);
 	if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
 		tsk->flags |= PF_EXITING;
 		threadgroup_change_end(tsk);
 		return;
 	}
 	spin_lock_irq(&tsk->sighand->siglock);
 	/*
 	 * From now this task is not visible for group-wide signals,
 	 * see wants_signal(), do_signal_stop().
 	 */
 	tsk->flags |= PF_EXITING;
 	threadgroup_change_end(tsk);
 	if (!signal_pending(tsk))
 		goto out;
 	unblocked = tsk->blocked;
 	signotset(&unblocked);
 	retarget_shared_pending(tsk, &unblocked);
 	if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
 	    task_participate_group_stop(tsk))
 		group_stop = CLD_STOPPED;
 out:
 	spin_unlock_irq(&tsk->sighand->siglock);
 	/*
 	 * If group stop has completed, deliver the notification.  This
 	 * should always go to the real parent of the group leader.
 	 */
 	if (unlikely(group_stop)) {
 		read_lock(&tasklist_lock);
 		do_notify_parent_cldstop(tsk, false, group_stop);
 		read_unlock(&tasklist_lock);
 	}
 }
 EXPORT_SYMBOL(recalc_sigpending);
 EXPORT_SYMBOL_GPL(dequeue_signal);
 EXPORT_SYMBOL(flush_signals);
 EXPORT_SYMBOL(force_sig);
 EXPORT_SYMBOL(send_sig);
 EXPORT_SYMBOL(send_sig_info);
 EXPORT_SYMBOL(sigprocmask);
 EXPORT_SYMBOL(block_all_signals);
 EXPORT_SYMBOL(unblock_all_signals);
 /*
  * System call entry points.
  */
 /**
  *  sys_restart_syscall - restart a system call
  */
 SYSCALL_DEFINE0(restart_syscall)
 {
 	struct restart_block *restart = &current_thread_info()->restart_block;
 	return restart->fn(restart);
 }
 long do_no_restart_syscall(struct restart_block *param)
 {
 	return -EINTR;
 }
 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
 {
 	if (signal_pending(tsk) && !thread_group_empty(tsk)) {
 		sigset_t newblocked;
 		/* A set of now blocked but previously unblocked signals. */
 		sigandnsets(&newblocked, newset, &current->blocked);
 		retarget_shared_pending(tsk, &newblocked);
 	}
 	tsk->blocked = *newset;
 	recalc_sigpending();
 }
 /**
  * set_current_blocked - change current->blocked mask
  * @newset: new mask
  *
  * It is wrong to change ->blocked directly, this helper should be used
  * to ensure the process can't miss a shared signal we are going to block.
  */
 void set_current_blocked(sigset_t *newset)
 {
 	struct task_struct *tsk = current;
 	sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
 	spin_lock_irq(&tsk->sighand->siglock);
 	__set_task_blocked(tsk, newset);
 	spin_unlock_irq(&tsk->sighand->siglock);
 }
 void __set_current_blocked(const sigset_t *newset)
 {
 	struct task_struct *tsk = current;
 	spin_lock_irq(&tsk->sighand->siglock);
 	__set_task_blocked(tsk, newset);
 	spin_unlock_irq(&tsk->sighand->siglock);
 }
 /*
  * This is also useful for kernel threads that want to temporarily
  * (or permanently) block certain signals.
  *
  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
  * interface happily blocks "unblockable" signals like SIGKILL
  * and friends.
  */
 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
 {
 	struct task_struct *tsk = current;
 	sigset_t newset;
 	/* Lockless, only current can change ->blocked, never from irq */
 	if (oldset)
 		*oldset = tsk->blocked;
 	switch (how) {
 	case SIG_BLOCK:
 		sigorsets(&newset, &tsk->blocked, set);
 		break;
 	case SIG_UNBLOCK:
 		sigandnsets(&newset, &tsk->blocked, set);
 		break;
 	case SIG_SETMASK:
 		newset = *set;
 		break;
 	default:
 		return -EINVAL;
 	}
 	__set_current_blocked(&newset);
 	return 0;
 }
 /**
  *  sys_rt_sigprocmask - change the list of currently blocked signals
  *  @how: whether to add, remove, or set signals
  *  @nset: stores pending signals
  *  @oset: previous value of signal mask if non-null
  *  @sigsetsize: size of sigset_t type
  */
 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
 		sigset_t __user *, oset, size_t, sigsetsize)
 {
 	sigset_t old_set, new_set;
 	int error;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		return -EINVAL;
 	old_set = current->blocked;
 	if (nset) {
 		if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
 			return -EFAULT;
 		sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
 		error = sigprocmask(how, &new_set, NULL);
 		if (error)
 			return error;
 	}
 	if (oset) {
 		if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
 			return -EFAULT;
 	}
 	return 0;
 }
 long do_sigpending(void __user *set, unsigned long sigsetsize)
 {
 	long error = -EINVAL;
 	sigset_t pending;
 	if (sigsetsize > sizeof(sigset_t))
 		goto out;
 	spin_lock_irq(&current->sighand->siglock);
 	sigorsets(&pending, &current->pending.signal,
 		  &current->signal->shared_pending.signal);
 	spin_unlock_irq(&current->sighand->siglock);
 	/* Outside the lock because only this thread touches it.  */
 	sigandsets(&pending, &current->blocked, &pending);
 	error = -EFAULT;
 	if (!copy_to_user(set, &pending, sigsetsize))
 		error = 0;
 out:
 	return error;
 }
 /**
  *  sys_rt_sigpending - examine a pending signal that has been raised
  *			while blocked
  *  @set: stores pending signals
  *  @sigsetsize: size of sigset_t type or larger
  */
 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
 {
 	return do_sigpending(set, sigsetsize);
 }
 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
 {
 	int err;
 	if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
 		return -EFAULT;
 	if (from->si_code < 0)
 		return __copy_to_user(to, from, sizeof(siginfo_t))
 			? -EFAULT : 0;
 	/*
 	 * If you change siginfo_t structure, please be sure
 	 * this code is fixed accordingly.
 	 * Please remember to update the signalfd_copyinfo() function
 	 * inside fs/signalfd.c too, in case siginfo_t changes.
 	 * 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.
 	 */
 	err = __put_user(from->si_signo, &to->si_signo);
 	err |= __put_user(from->si_errno, &to->si_errno);
 	err |= __put_user((short)from->si_code, &to->si_code);
 	switch (from->si_code & __SI_MASK) {
 	case __SI_KILL:
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		break;
 	case __SI_TIMER:
 		 err |= __put_user(from->si_tid, &to->si_tid);
 		 err |= __put_user(from->si_overrun, &to->si_overrun);
 		 err |= __put_user(from->si_ptr, &to->si_ptr);
 		break;
 	case __SI_POLL:
 		err |= __put_user(from->si_band, &to->si_band);
 		err |= __put_user(from->si_fd, &to->si_fd);
 		break;
 	case __SI_FAULT:
 		err |= __put_user(from->si_addr, &to->si_addr);
 #ifdef __ARCH_SI_TRAPNO
 		err |= __put_user(from->si_trapno, &to->si_trapno);
 #endif
 #ifdef BUS_MCEERR_AO
 		/*
 		 * Other callers might not initialize the si_lsb field,
 		 * so check explicitly for the right codes here.
 		 */
 		if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
 			err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
 #endif
 		break;
 	case __SI_CHLD:
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		err |= __put_user(from->si_status, &to->si_status);
 		err |= __put_user(from->si_utime, &to->si_utime);
 		err |= __put_user(from->si_stime, &to->si_stime);
 		break;
 	case __SI_RT: /* This is not generated by the kernel as of now. */
 	case __SI_MESGQ: /* But this is */
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		err |= __put_user(from->si_ptr, &to->si_ptr);
 		break;
 #ifdef __ARCH_SIGSYS
 	case __SI_SYS:
 		err |= __put_user(from->si_call_addr, &to->si_call_addr);
 		err |= __put_user(from->si_syscall, &to->si_syscall);
 		err |= __put_user(from->si_arch, &to->si_arch);
 		break;
 #endif
 	default: /* this is just in case for now ... */
 		err |= __put_user(from->si_pid, &to->si_pid);
 		err |= __put_user(from->si_uid, &to->si_uid);
 		break;
 	}
 	return err;
 }
 #endif
 /**
  *  do_sigtimedwait - wait for queued signals specified in @which
  *  @which: queued signals to wait for
  *  @info: if non-null, the signal's siginfo is returned here
  *  @ts: upper bound on process time suspension
  */
 int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
 			const struct timespec *ts)
 {
 	struct task_struct *tsk = current;
 	long timeout = MAX_SCHEDULE_TIMEOUT;
 	sigset_t mask = *which;
 	int sig;
 	if (ts) {
 		if (!timespec_valid(ts))
 			return -EINVAL;
 		timeout = timespec_to_jiffies(ts);
 		/*
 		 * We can be close to the next tick, add another one
 		 * to ensure we will wait at least the time asked for.
 		 */
 		if (ts->tv_sec || ts->tv_nsec)
 			timeout++;
 	}
 	/*
 	 * Invert the set of allowed signals to get those we want to block.
 	 */
 	sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
 	signotset(&mask);
 	spin_lock_irq(&tsk->sighand->siglock);
 	sig = dequeue_signal(tsk, &mask, info);
 	if (!sig && timeout) {
 		/*
 		 * None ready, temporarily unblock those we're interested
 		 * while we are sleeping in so that we'll be awakened when
 		 * they arrive. Unblocking is always fine, we can avoid
 		 * set_current_blocked().
 		 */
 		tsk->real_blocked = tsk->blocked;
 		sigandsets(&tsk->blocked, &tsk->blocked, &mask);
 		recalc_sigpending();
 		spin_unlock_irq(&tsk->sighand->siglock);
 		timeout = schedule_timeout_interruptible(timeout);
 		spin_lock_irq(&tsk->sighand->siglock);
 		__set_task_blocked(tsk, &tsk->real_blocked);
 		siginitset(&tsk->real_blocked, 0);
 		sig = dequeue_signal(tsk, &mask, info);
 	}
 	spin_unlock_irq(&tsk->sighand->siglock);
 	if (sig)
 		return sig;
 	return timeout ? -EINTR : -EAGAIN;
 }
 /**
  *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
  *			in @uthese
  *  @uthese: queued signals to wait for
  *  @uinfo: if non-null, the signal's siginfo is returned here
  *  @uts: upper bound on process time suspension
  *  @sigsetsize: size of sigset_t type
  */
 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
 		siginfo_t __user *, uinfo, const struct timespec __user *, uts,
 		size_t, sigsetsize)
 {
 	sigset_t these;
 	struct timespec ts;
 	siginfo_t info;
 	int ret;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		return -EINVAL;
 	if (copy_from_user(&these, uthese, sizeof(these)))
 		return -EFAULT;
 	if (uts) {
 		if (copy_from_user(&ts, uts, sizeof(ts)))
 			return -EFAULT;
 	}
 	ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
 	if (ret > 0 && uinfo) {
 		if (copy_siginfo_to_user(uinfo, &info))
 			ret = -EFAULT;
 	}
 	return ret;
 }
 /**
  *  sys_kill - send a signal to a process
  *  @pid: the PID of the process
  *  @sig: signal to be sent
  */
 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
 {
 	struct siginfo info;
 	info.si_signo = sig;
 	info.si_errno = 0;
 	info.si_code = SI_USER;
 	info.si_pid = task_tgid_vnr(current);
 	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
 	return kill_something_info(sig, &info, pid);
 }
 static int
 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
 {
 	struct task_struct *p;
 	int error = -ESRCH;
 	rcu_read_lock();
 	p = find_task_by_vpid(pid);
 	if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
 		error = check_kill_permission(sig, info, p);
 		/*
 		 * The null signal is a permissions and process existence
 		 * probe.  No signal is actually delivered.
 		 */
 		if (!error && sig) {
 			error = do_send_sig_info(sig, info, p, false);
 			/*
 			 * If lock_task_sighand() failed we pretend the task
 			 * dies after receiving the signal. The window is tiny,
 			 * and the signal is private anyway.
 			 */
 			if (unlikely(error == -ESRCH))
 				error = 0;
 		}
 	}
 	rcu_read_unlock();
 	return error;
 }
 static int do_tkill(pid_t tgid, pid_t pid, int sig)
 {
 	struct siginfo info;
 	info.si_signo = sig;
 	info.si_errno = 0;
 	info.si_code = SI_TKILL;
 	info.si_pid = task_tgid_vnr(current);
 	info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
 	return do_send_specific(tgid, pid, sig, &info);
 }
 /**
  *  sys_tgkill - send signal to one specific thread
  *  @tgid: the thread group ID of the thread
  *  @pid: the PID of the thread
  *  @sig: signal to be sent
  *
  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
  *  exists but it's not belonging to the target process anymore. This
  *  method solves the problem of threads exiting and PIDs getting reused.
  */
 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
 {
 	/* This is only valid for single tasks */
 	if (pid <= 0 || tgid <= 0)
 		return -EINVAL;
 	return do_tkill(tgid, pid, sig);
 }
 /**
  *  sys_tkill - send signal to one specific task
  *  @pid: the PID of the task
  *  @sig: signal to be sent
  *
  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
  */
 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
 {
 	/* This is only valid for single tasks */
 	if (pid <= 0)
 		return -EINVAL;
 	return do_tkill(0, pid, sig);
 }
 /**
  *  sys_rt_sigqueueinfo - send signal information to a signal
  *  @pid: the PID of the thread
  *  @sig: signal to be sent
  *  @uinfo: signal info to be sent
  */
 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
 		siginfo_t __user *, uinfo)
 {
 	siginfo_t info;
 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
 		return -EFAULT;
 	/* Not even root can pretend to send signals from the kernel.
 	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
 	 */
 	if (info.si_code >= 0 || info.si_code == SI_TKILL) {
 		/* We used to allow any < 0 si_code */
 		WARN_ON_ONCE(info.si_code < 0);
 		return -EPERM;
 	}
 	info.si_signo = sig;
 	/* POSIX.1b doesn't mention process groups.  */
 	return kill_proc_info(sig, &info, pid);
 }
 long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
 {
 	/* This is only valid for single tasks */
 	if (pid <= 0 || tgid <= 0)
 		return -EINVAL;
 	/* Not even root can pretend to send signals from the kernel.
 	 * Nor can they impersonate a kill()/tgkill(), which adds source info.
 	 */
 	if (info->si_code >= 0 || info->si_code == SI_TKILL) {
 		/* We used to allow any < 0 si_code */
 		WARN_ON_ONCE(info->si_code < 0);
 		return -EPERM;
 	}
 	info->si_signo = sig;
 	return do_send_specific(tgid, pid, sig, info);
 }
 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
 		siginfo_t __user *, uinfo)
 {
 	siginfo_t info;
 	if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
 		return -EFAULT;
 	return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
 }
 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
 {
 	struct task_struct *t = current;
 	struct k_sigaction *k;
 	sigset_t mask;
 	if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
 		return -EINVAL;
 	k = &t->sighand->action[sig-1];
 	spin_lock_irq(&current->sighand->siglock);
 	if (oact)
 		*oact = *k;
 	if (act) {
 		sigdelsetmask(&act->sa.sa_mask,
 			      sigmask(SIGKILL) | sigmask(SIGSTOP));
 		*k = *act;
 		/*
 		 * POSIX 3.3.1.3:
 		 *  "Setting a signal action to SIG_IGN for a signal that is
 		 *   pending shall cause the pending signal to be discarded,
 		 *   whether or not it is blocked."
 		 *
 		 *  "Setting a signal action to SIG_DFL for a signal that is
 		 *   pending and whose default action is to ignore the signal
 		 *   (for example, SIGCHLD), shall cause the pending signal to
 		 *   be discarded, whether or not it is blocked"
 		 */
 		if (sig_handler_ignored(sig_handler(t, sig), sig)) {
 			sigemptyset(&mask);
 			sigaddset(&mask, sig);
 			rm_from_queue_full(&mask, &t->signal->shared_pending);
 			do {
 				rm_from_queue_full(&mask, &t->pending);
 				t = next_thread(t);
 			} while (t != current);
 		}
 	}
 	spin_unlock_irq(&current->sighand->siglock);
 	return 0;
 }
 int
 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
 {
 	stack_t oss;
 	int error;
 	oss.ss_sp = (void __user *) current->sas_ss_sp;
 	oss.ss_size = current->sas_ss_size;
 	oss.ss_flags = sas_ss_flags(sp);
 	if (uss) {
 		void __user *ss_sp;
 		size_t ss_size;
 		int ss_flags;
 		error = -EFAULT;
 		if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
 			goto out;
 		error = __get_user(ss_sp, &uss->ss_sp) |
 			__get_user(ss_flags, &uss->ss_flags) |
 			__get_user(ss_size, &uss->ss_size);
 		if (error)
 			goto out;
 		error = -EPERM;
 		if (on_sig_stack(sp))
 			goto out;
 		error = -EINVAL;
 		/*
 		 * Note - this code used to test ss_flags incorrectly:
 		 *  	  old code may have been written using ss_flags==0
 		 *	  to mean ss_flags==SS_ONSTACK (as this was the only
 		 *	  way that worked) - this fix preserves that older
 		 *	  mechanism.
 		 */
 		if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
 			goto out;
 		if (ss_flags == SS_DISABLE) {
 			ss_size = 0;
 			ss_sp = NULL;
 		} else {
 			error = -ENOMEM;
 			if (ss_size < MINSIGSTKSZ)
 				goto out;
 		}
 		current->sas_ss_sp = (unsigned long) ss_sp;
 		current->sas_ss_size = ss_size;
 	}
 	error = 0;
 	if (uoss) {
 		error = -EFAULT;
 		if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
 			goto out;
 		error = __put_user(oss.ss_sp, &uoss->ss_sp) |
 			__put_user(oss.ss_size, &uoss->ss_size) |
 			__put_user(oss.ss_flags, &uoss->ss_flags);
 	}
 out:
 	return error;
 }
 #ifdef CONFIG_GENERIC_SIGALTSTACK
 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
 {
 	return do_sigaltstack(uss, uoss, current_user_stack_pointer());
 }
 #endif
 int restore_altstack(const stack_t __user *uss)
 {
 	int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
 	/* squash all but EFAULT for now */
 	return err == -EFAULT ? err : 0;
 }
+#ifdef CONFIG_COMPAT
+#ifdef CONFIG_GENERIC_SIGALTSTACK
+asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
+				       compat_stack_t __user *uoss_ptr)
+{
+	stack_t uss, uoss;
+	int ret;
+	mm_segment_t seg;
+	if (uss_ptr) {
+		compat_stack_t uss32;
+		memset(&uss, 0, sizeof(stack_t));
+		if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
+			return -EFAULT;
+		uss.ss_sp = compat_ptr(uss32.ss_sp);
+		uss.ss_flags = uss32.ss_flags;
+		uss.ss_size = uss32.ss_size;
+	}
+	seg = get_fs();
+	set_fs(KERNEL_DS);
+	ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
+			     (stack_t __force __user *) &uoss,
+			     compat_user_stack_pointer());
+	set_fs(seg);
+	if (ret >= 0 && uoss_ptr)  {
+		if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
+		    __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
+		    __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
+		    __put_user(uoss.ss_size, &uoss_ptr->ss_size))
+			ret = -EFAULT;
+	}
+	return ret;
+}
+int compat_restore_altstack(const compat_stack_t __user *uss)
+{
+	int err = compat_sys_sigaltstack(uss, NULL);
+	/* squash all but -EFAULT for now */
+	return err == -EFAULT ? err : 0;
+}
+#endif
+#endif
 #ifdef __ARCH_WANT_SYS_SIGPENDING
 /**
  *  sys_sigpending - examine pending signals
  *  @set: where mask of pending signal is returned
  */
 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
 {
 	return do_sigpending(set, sizeof(*set));
 }
 #endif
 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
 /**
  *  sys_sigprocmask - examine and change blocked signals
  *  @how: whether to add, remove, or set signals
  *  @nset: signals to add or remove (if non-null)
  *  @oset: previous value of signal mask if non-null
  *
  * Some platforms have their own version with special arguments;
  * others support only sys_rt_sigprocmask.
  */
 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
 		old_sigset_t __user *, oset)
 {
 	old_sigset_t old_set, new_set;
 	sigset_t new_blocked;
 	old_set = current->blocked.sig[0];
 	if (nset) {
 		if (copy_from_user(&new_set, nset, sizeof(*nset)))
 			return -EFAULT;
 		new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
 		new_blocked = current->blocked;
 		switch (how) {
 		case SIG_BLOCK:
 			sigaddsetmask(&new_blocked, new_set);
 			break;
 		case SIG_UNBLOCK:
 			sigdelsetmask(&new_blocked, new_set);
 			break;
 		case SIG_SETMASK:
 			new_blocked.sig[0] = new_set;
 			break;
 		default:
 			return -EINVAL;
 		}
 		__set_current_blocked(&new_blocked);
 	}
 	if (oset) {
 		if (copy_to_user(oset, &old_set, sizeof(*oset)))
 			return -EFAULT;
 	}
 	return 0;
 }
 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
 /**
  *  sys_rt_sigaction - alter an action taken by a process
  *  @sig: signal to be sent
  *  @act: new sigaction
  *  @oact: used to save the previous sigaction
  *  @sigsetsize: size of sigset_t type
  */
 SYSCALL_DEFINE4(rt_sigaction, int, sig,
 		const struct sigaction __user *, act,
 		struct sigaction __user *, oact,
 		size_t, sigsetsize)
 {
 	struct k_sigaction new_sa, old_sa;
 	int ret = -EINVAL;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		goto out;
 	if (act) {
 		if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
 			return -EFAULT;
 	}
 	ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
 	if (!ret && oact) {
 		if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
 			return -EFAULT;
 	}
 out:
 	return ret;
 }
 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
 #ifdef __ARCH_WANT_SYS_SGETMASK
 /*
  * For backwards compatibility.  Functionality superseded by sigprocmask.
  */
 SYSCALL_DEFINE0(sgetmask)
 {
 	/* SMP safe */
 	return current->blocked.sig[0];
 }
 SYSCALL_DEFINE1(ssetmask, int, newmask)
 {
 	int old = current->blocked.sig[0];
 	sigset_t newset;
 	set_current_blocked(&newset);
 	return old;
 }
 #endif /* __ARCH_WANT_SGETMASK */
 #ifdef __ARCH_WANT_SYS_SIGNAL
 /*
  * For backwards compatibility.  Functionality superseded by sigaction.
  */
 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
 {
 	struct k_sigaction new_sa, old_sa;
 	int ret;
 	new_sa.sa.sa_handler = handler;
 	new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
 	sigemptyset(&new_sa.sa.sa_mask);
 	ret = do_sigaction(sig, &new_sa, &old_sa);
 	return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
 }
 #endif /* __ARCH_WANT_SYS_SIGNAL */
 #ifdef __ARCH_WANT_SYS_PAUSE
 SYSCALL_DEFINE0(pause)
 {
 	while (!signal_pending(current)) {
 		current->state = TASK_INTERRUPTIBLE;
 		schedule();
 	}
 	return -ERESTARTNOHAND;
 }
 #endif
 int sigsuspend(sigset_t *set)
 {
 	current->saved_sigmask = current->blocked;
 	set_current_blocked(set);
 	current->state = TASK_INTERRUPTIBLE;
 	schedule();
 	set_restore_sigmask();
 	return -ERESTARTNOHAND;
 }
 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
 /**
  *  sys_rt_sigsuspend - replace the signal mask for a value with the
  *	@unewset value until a signal is received
  *  @unewset: new signal mask value
  *  @sigsetsize: size of sigset_t type
  */
 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
 {
 	sigset_t newset;
 	/* XXX: Don't preclude handling different sized sigset_t's.  */
 	if (sigsetsize != sizeof(sigset_t))
 		return -EINVAL;
 	if (copy_from_user(&newset, unewset, sizeof(newset)))
 		return -EFAULT;
 	return sigsuspend(&newset);
 }
 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
 {
 	return NULL;
 }
 void __init signals_init(void)
 {
 	sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
 }
 #ifdef CONFIG_KGDB_KDB
 #include <linux/kdb.h>
 /*
  * kdb_send_sig_info - Allows kdb to send signals without exposing
  * signal internals.  This function checks if the required locks are
  * available before calling the main signal code, to avoid kdb
  * deadlocks.
  */
 void
 kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
 {
 	static struct task_struct *kdb_prev_t;
 	int sig, new_t;
 	if (!spin_trylock(&t->sighand->siglock)) {
 		kdb_printf("Can't do kill command now.\n"
 			   "The sigmask lock is held somewhere else in "
 			   "kernel, try again later\n");
 		return;
 	}
 	spin_unlock(&t->sighand->siglock);
 	new_t = kdb_prev_t != t;
 	kdb_prev_t = t;
 	if (t->state != TASK_RUNNING && new_t) {
 		kdb_printf("Process is not RUNNING, sending a signal from "
 			   "kdb risks deadlock\n"
 			   "on the run queue locks. "
 			   "The signal has _not_ been sent.\n"
 			   "Reissue the kill command if you want to risk "
 			   "the deadlock.\n");
 		return;
 	}
 	sig = info->si_signo;
 	if (send_sig_info(sig, info, t))
 		kdb_printf("Fail to deliver Signal %d to process %d.\n",
 			   sig, t->pid);
 	else
 		kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
 }
 #endif	/* CONFIG_KGDB_KDB */