Commit 8a68bd3e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'x86-core-2023-02-20' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip 

Pull x86 core updates from Ingo Molnar:

 - Clean up the signal frame layout tests

 - Suppress KMSAN false positive reports in arch_within_stack_frames()

* tag 'x86-core-2023-02-20' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  x86: Suppress KMSAN reports in arch_within_stack_frames()
  x86/signal/compat: Move sigaction_compat_abi() to signal_64.c
  x86/signal: Move siginfo field tests
parents 572640f0 ce3ba2af

arch/x86/include/asm/thread_info.h

+5 −0
Original line number Diff line number Diff line
@@ -163,7 +163,12 @@ struct thread_info { 
 *	GOOD_FRAME	if within a frame

 *	BAD_STACK	if placed across a frame boundary (or outside stack)

 *	NOT_STACK	unable to determine (no frame pointers, etc)

 *

 * This function reads pointers from the stack and dereferences them. The

 * pointers may not have their KMSAN shadow set up properly, which may result

 * in false positive reports. Disable instrumentation to avoid those.

 */

__no_kmsan_checks

static inline int arch_within_stack_frames(const void * const stack,

					   const void * const stackend,

					   const void *obj, unsigned long len)

arch/x86/kernel/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -45,7 +45,6 @@ obj-y += head$(BITS).o 
obj-y			+= ebda.o

obj-y			+= platform-quirks.o

obj-y			+= process_$(BITS).o signal.o signal_$(BITS).o

obj-$(CONFIG_COMPAT)	+= signal_compat.o

obj-y			+= traps.o idt.o irq.o irq_$(BITS).o dumpstack_$(BITS).o

obj-y			+= time.o ioport.o dumpstack.o nmi.o

obj-$(CONFIG_MODIFY_LDT_SYSCALL)	+= ldt.o

arch/x86/kernel/signal_32.c

+127 −0
Original line number Diff line number Diff line
@@ -54,12 +54,14 @@ static inline void reload_segments(struct sigcontext_32 *sc) 
}



#define sigset32_t			compat_sigset_t

#define siginfo32_t			compat_siginfo_t

#define restore_altstack32		compat_restore_altstack

#define unsafe_save_altstack32		unsafe_compat_save_altstack



#else



#define sigset32_t			sigset_t

#define siginfo32_t			siginfo_t

#define __NR_ia32_sigreturn		__NR_sigreturn

#define __NR_ia32_rt_sigreturn		__NR_rt_sigreturn

#define restore_altstack32		restore_altstack
@@ -377,3 +379,128 @@ int ia32_setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs) 
	user_access_end();

	return -EFAULT;

}



/*

 * The siginfo_t structure and handing code is very easy

 * to break in several ways.  It must always be updated when new

 * updates are made to the main siginfo_t, and

 * copy_siginfo_to_user32() must be updated when the

 * (arch-independent) copy_siginfo_to_user() is updated.

 *

 * It is also easy to put a new member in the siginfo_t

 * which has implicit alignment which can move internal structure

 * alignment around breaking the ABI.  This can happen if you,

 * for instance, put a plain 64-bit value in there.

 */



/*

* If adding a new si_code, there is probably new data in

* the siginfo.  Make sure folks bumping the si_code

* limits also have to look at this code.  Make sure any

* new fields are handled in copy_siginfo_to_user32()!

*/

static_assert(NSIGILL  == 11);

static_assert(NSIGFPE  == 15);

static_assert(NSIGSEGV == 9);

static_assert(NSIGBUS  == 5);

static_assert(NSIGTRAP == 6);

static_assert(NSIGCHLD == 6);

static_assert(NSIGSYS  == 2);



/* This is part of the ABI and can never change in size: */

static_assert(sizeof(siginfo32_t) == 128);



/* This is a part of the ABI and can never change in alignment */

static_assert(__alignof__(siginfo32_t) == 4);



/*

* The offsets of all the (unioned) si_fields are fixed

* in the ABI, of course.  Make sure none of them ever

* move and are always at the beginning:

*/

static_assert(offsetof(siginfo32_t, _sifields) == 3 * sizeof(int));



static_assert(offsetof(siginfo32_t, si_signo) == 0);

static_assert(offsetof(siginfo32_t, si_errno) == 4);

static_assert(offsetof(siginfo32_t, si_code)  == 8);



/*

* Ensure that the size of each si_field never changes.

* If it does, it is a sign that the

* copy_siginfo_to_user32() code below needs to updated

* along with the size in the CHECK_SI_SIZE().

*

* We repeat this check for both the generic and compat

* siginfos.

*

* Note: it is OK for these to grow as long as the whole

* structure stays within the padding size (checked

* above).

*/



#define CHECK_SI_OFFSET(name)						\

	static_assert(offsetof(siginfo32_t, _sifields) ==		\

		      offsetof(siginfo32_t, _sifields.name))



#define CHECK_SI_SIZE(name, size)					\

	static_assert(sizeof_field(siginfo32_t, _sifields.name) == size)



CHECK_SI_OFFSET(_kill);

CHECK_SI_SIZE  (_kill, 2*sizeof(int));

static_assert(offsetof(siginfo32_t, si_pid) == 0xC);

static_assert(offsetof(siginfo32_t, si_uid) == 0x10);



CHECK_SI_OFFSET(_timer);

#ifdef CONFIG_COMPAT

/* compat_siginfo_t doesn't have si_sys_private */

CHECK_SI_SIZE  (_timer, 3*sizeof(int));

#else

CHECK_SI_SIZE  (_timer, 4*sizeof(int));

#endif

static_assert(offsetof(siginfo32_t, si_tid)     == 0x0C);

static_assert(offsetof(siginfo32_t, si_overrun) == 0x10);

static_assert(offsetof(siginfo32_t, si_value)   == 0x14);



CHECK_SI_OFFSET(_rt);

CHECK_SI_SIZE  (_rt, 3*sizeof(int));

static_assert(offsetof(siginfo32_t, si_pid)   == 0x0C);

static_assert(offsetof(siginfo32_t, si_uid)   == 0x10);

static_assert(offsetof(siginfo32_t, si_value) == 0x14);



CHECK_SI_OFFSET(_sigchld);

CHECK_SI_SIZE  (_sigchld, 5*sizeof(int));

static_assert(offsetof(siginfo32_t, si_pid)    == 0x0C);

static_assert(offsetof(siginfo32_t, si_uid)    == 0x10);

static_assert(offsetof(siginfo32_t, si_status) == 0x14);

static_assert(offsetof(siginfo32_t, si_utime)  == 0x18);

static_assert(offsetof(siginfo32_t, si_stime)  == 0x1C);



CHECK_SI_OFFSET(_sigfault);

CHECK_SI_SIZE  (_sigfault, 4*sizeof(int));

static_assert(offsetof(siginfo32_t, si_addr) == 0x0C);



static_assert(offsetof(siginfo32_t, si_trapno) == 0x10);



static_assert(offsetof(siginfo32_t, si_addr_lsb) == 0x10);



static_assert(offsetof(siginfo32_t, si_lower) == 0x14);

static_assert(offsetof(siginfo32_t, si_upper) == 0x18);



static_assert(offsetof(siginfo32_t, si_pkey) == 0x14);



static_assert(offsetof(siginfo32_t, si_perf_data) == 0x10);

static_assert(offsetof(siginfo32_t, si_perf_type) == 0x14);

static_assert(offsetof(siginfo32_t, si_perf_flags) == 0x18);



CHECK_SI_OFFSET(_sigpoll);

CHECK_SI_SIZE  (_sigpoll, 2*sizeof(int));

static_assert(offsetof(siginfo32_t, si_band) == 0x0C);

static_assert(offsetof(siginfo32_t, si_fd)   == 0x10);



CHECK_SI_OFFSET(_sigsys);

CHECK_SI_SIZE  (_sigsys, 3*sizeof(int));

static_assert(offsetof(siginfo32_t, si_call_addr) == 0x0C);

static_assert(offsetof(siginfo32_t, si_syscall)   == 0x10);

static_assert(offsetof(siginfo32_t, si_arch)      == 0x14);



/* any new si_fields should be added here */

arch/x86/kernel/signal_64.c

+127 −0
Original line number Diff line number Diff line
@@ -381,3 +381,130 @@ COMPAT_SYSCALL_DEFINE0(x32_rt_sigreturn) 
	return 0;

}

#endif /* CONFIG_X86_X32_ABI */



#ifdef CONFIG_COMPAT

void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact)

{

	if (!act)

		return;



	if (in_ia32_syscall())

		act->sa.sa_flags |= SA_IA32_ABI;

	if (in_x32_syscall())

		act->sa.sa_flags |= SA_X32_ABI;

}

#endif /* CONFIG_COMPAT */



/*

* If adding a new si_code, there is probably new data in

* the siginfo.  Make sure folks bumping the si_code

* limits also have to look at this code.  Make sure any

* new fields are handled in copy_siginfo_to_user32()!

*/

static_assert(NSIGILL  == 11);

static_assert(NSIGFPE  == 15);

static_assert(NSIGSEGV == 9);

static_assert(NSIGBUS  == 5);

static_assert(NSIGTRAP == 6);

static_assert(NSIGCHLD == 6);

static_assert(NSIGSYS  == 2);



/* This is part of the ABI and can never change in size: */

static_assert(sizeof(siginfo_t) == 128);



/* This is a part of the ABI and can never change in alignment */

static_assert(__alignof__(siginfo_t) == 8);



/*

* The offsets of all the (unioned) si_fields are fixed

* in the ABI, of course.  Make sure none of them ever

* move and are always at the beginning:

*/

static_assert(offsetof(siginfo_t, si_signo) == 0);

static_assert(offsetof(siginfo_t, si_errno) == 4);

static_assert(offsetof(siginfo_t, si_code)  == 8);



/*

* Ensure that the size of each si_field never changes.

* If it does, it is a sign that the

* copy_siginfo_to_user32() code below needs to updated

* along with the size in the CHECK_SI_SIZE().

*

* We repeat this check for both the generic and compat

* siginfos.

*

* Note: it is OK for these to grow as long as the whole

* structure stays within the padding size (checked

* above).

*/



#define CHECK_SI_OFFSET(name)						\

	static_assert(offsetof(siginfo_t, _sifields) == 		\

		      offsetof(siginfo_t, _sifields.name))

#define CHECK_SI_SIZE(name, size)					\

	static_assert(sizeof_field(siginfo_t, _sifields.name) == size)



CHECK_SI_OFFSET(_kill);

CHECK_SI_SIZE  (_kill, 2*sizeof(int));

static_assert(offsetof(siginfo_t, si_pid) == 0x10);

static_assert(offsetof(siginfo_t, si_uid) == 0x14);



CHECK_SI_OFFSET(_timer);

CHECK_SI_SIZE  (_timer, 6*sizeof(int));

static_assert(offsetof(siginfo_t, si_tid)     == 0x10);

static_assert(offsetof(siginfo_t, si_overrun) == 0x14);

static_assert(offsetof(siginfo_t, si_value)   == 0x18);



CHECK_SI_OFFSET(_rt);

CHECK_SI_SIZE  (_rt, 4*sizeof(int));

static_assert(offsetof(siginfo_t, si_pid)   == 0x10);

static_assert(offsetof(siginfo_t, si_uid)   == 0x14);

static_assert(offsetof(siginfo_t, si_value) == 0x18);



CHECK_SI_OFFSET(_sigchld);

CHECK_SI_SIZE  (_sigchld, 8*sizeof(int));

static_assert(offsetof(siginfo_t, si_pid)    == 0x10);

static_assert(offsetof(siginfo_t, si_uid)    == 0x14);

static_assert(offsetof(siginfo_t, si_status) == 0x18);

static_assert(offsetof(siginfo_t, si_utime)  == 0x20);

static_assert(offsetof(siginfo_t, si_stime)  == 0x28);



#ifdef CONFIG_X86_X32_ABI

/* no _sigchld_x32 in the generic siginfo_t */

static_assert(sizeof_field(compat_siginfo_t, _sifields._sigchld_x32) ==

	      7*sizeof(int));

static_assert(offsetof(compat_siginfo_t, _sifields) ==

	      offsetof(compat_siginfo_t, _sifields._sigchld_x32));

static_assert(offsetof(compat_siginfo_t, _sifields._sigchld_x32._utime)  == 0x18);

static_assert(offsetof(compat_siginfo_t, _sifields._sigchld_x32._stime)  == 0x20);

#endif



CHECK_SI_OFFSET(_sigfault);

CHECK_SI_SIZE  (_sigfault, 8*sizeof(int));

static_assert(offsetof(siginfo_t, si_addr)	== 0x10);



static_assert(offsetof(siginfo_t, si_trapno)	== 0x18);



static_assert(offsetof(siginfo_t, si_addr_lsb)	== 0x18);



static_assert(offsetof(siginfo_t, si_lower)	== 0x20);

static_assert(offsetof(siginfo_t, si_upper)	== 0x28);



static_assert(offsetof(siginfo_t, si_pkey)	== 0x20);



static_assert(offsetof(siginfo_t, si_perf_data)	 == 0x18);

static_assert(offsetof(siginfo_t, si_perf_type)	 == 0x20);

static_assert(offsetof(siginfo_t, si_perf_flags) == 0x24);



CHECK_SI_OFFSET(_sigpoll);

CHECK_SI_SIZE  (_sigpoll, 4*sizeof(int));

static_assert(offsetof(siginfo_t, si_band) == 0x10);

static_assert(offsetof(siginfo_t, si_fd)   == 0x18);



CHECK_SI_OFFSET(_sigsys);

CHECK_SI_SIZE  (_sigsys, 4*sizeof(int));

static_assert(offsetof(siginfo_t, si_call_addr) == 0x10);

static_assert(offsetof(siginfo_t, si_syscall)   == 0x18);

static_assert(offsetof(siginfo_t, si_arch)      == 0x1C);



/* any new si_fields should be added here */

arch/x86/kernel/signal_compat.c

deleted100644 → 0
+0 −191
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <linux/compat.h>

#include <linux/uaccess.h>

#include <linux/ptrace.h>



/*

 * The compat_siginfo_t structure and handing code is very easy

 * to break in several ways.  It must always be updated when new

 * updates are made to the main siginfo_t, and

 * copy_siginfo_to_user32() must be updated when the

 * (arch-independent) copy_siginfo_to_user() is updated.

 *

 * It is also easy to put a new member in the compat_siginfo_t

 * which has implicit alignment which can move internal structure

 * alignment around breaking the ABI.  This can happen if you,

 * for instance, put a plain 64-bit value in there.

 */

static inline void signal_compat_build_tests(void)

{

	int _sifields_offset = offsetof(compat_siginfo_t, _sifields);



	/*

	 * If adding a new si_code, there is probably new data in

	 * the siginfo.  Make sure folks bumping the si_code

	 * limits also have to look at this code.  Make sure any

	 * new fields are handled in copy_siginfo_to_user32()!

	 */

	BUILD_BUG_ON(NSIGILL  != 11);

	BUILD_BUG_ON(NSIGFPE  != 15);

	BUILD_BUG_ON(NSIGSEGV != 9);

	BUILD_BUG_ON(NSIGBUS  != 5);

	BUILD_BUG_ON(NSIGTRAP != 6);

	BUILD_BUG_ON(NSIGCHLD != 6);

	BUILD_BUG_ON(NSIGSYS  != 2);



	/* This is part of the ABI and can never change in size: */

	BUILD_BUG_ON(sizeof(siginfo_t) != 128);

	BUILD_BUG_ON(sizeof(compat_siginfo_t) != 128);



	/* This is a part of the ABI and can never change in alignment */

	BUILD_BUG_ON(__alignof__(siginfo_t) != 8);

	BUILD_BUG_ON(__alignof__(compat_siginfo_t) != 4);



	/*

	 * The offsets of all the (unioned) si_fields are fixed

	 * in the ABI, of course.  Make sure none of them ever

	 * move and are always at the beginning:

	 */

	BUILD_BUG_ON(offsetof(compat_siginfo_t, _sifields) != 3 * sizeof(int));

#define CHECK_CSI_OFFSET(name)	  BUILD_BUG_ON(_sifields_offset != offsetof(compat_siginfo_t, _sifields.name))



	BUILD_BUG_ON(offsetof(siginfo_t, si_signo) != 0);

	BUILD_BUG_ON(offsetof(siginfo_t, si_errno) != 4);

	BUILD_BUG_ON(offsetof(siginfo_t, si_code)  != 8);



	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_signo) != 0);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_errno) != 4);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_code)  != 8);

	 /*

	 * Ensure that the size of each si_field never changes.

	 * If it does, it is a sign that the

	 * copy_siginfo_to_user32() code below needs to updated

	 * along with the size in the CHECK_SI_SIZE().

	 *

	 * We repeat this check for both the generic and compat

	 * siginfos.

	 *

	 * Note: it is OK for these to grow as long as the whole

	 * structure stays within the padding size (checked

	 * above).

	 */

#define CHECK_CSI_SIZE(name, size) BUILD_BUG_ON(size != sizeof(((compat_siginfo_t *)0)->_sifields.name))

#define CHECK_SI_SIZE(name, size) BUILD_BUG_ON(size != sizeof(((siginfo_t *)0)->_sifields.name))



	CHECK_CSI_OFFSET(_kill);

	CHECK_CSI_SIZE  (_kill, 2*sizeof(int));

	CHECK_SI_SIZE   (_kill, 2*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_pid) != 0x10);

	BUILD_BUG_ON(offsetof(siginfo_t, si_uid) != 0x14);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_pid) != 0xC);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_uid) != 0x10);



	CHECK_CSI_OFFSET(_timer);

	CHECK_CSI_SIZE  (_timer, 3*sizeof(int));

	CHECK_SI_SIZE   (_timer, 6*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_tid)     != 0x10);

	BUILD_BUG_ON(offsetof(siginfo_t, si_overrun) != 0x14);

	BUILD_BUG_ON(offsetof(siginfo_t, si_value)   != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_tid)     != 0x0C);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_overrun) != 0x10);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_value)   != 0x14);



	CHECK_CSI_OFFSET(_rt);

	CHECK_CSI_SIZE  (_rt, 3*sizeof(int));

	CHECK_SI_SIZE   (_rt, 4*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_pid)   != 0x10);

	BUILD_BUG_ON(offsetof(siginfo_t, si_uid)   != 0x14);

	BUILD_BUG_ON(offsetof(siginfo_t, si_value) != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_pid)   != 0x0C);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_uid)   != 0x10);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_value) != 0x14);



	CHECK_CSI_OFFSET(_sigchld);

	CHECK_CSI_SIZE  (_sigchld, 5*sizeof(int));

	CHECK_SI_SIZE   (_sigchld, 8*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_pid)    != 0x10);

	BUILD_BUG_ON(offsetof(siginfo_t, si_uid)    != 0x14);

	BUILD_BUG_ON(offsetof(siginfo_t, si_status) != 0x18);

	BUILD_BUG_ON(offsetof(siginfo_t, si_utime)  != 0x20);

	BUILD_BUG_ON(offsetof(siginfo_t, si_stime)  != 0x28);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_pid)    != 0x0C);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_uid)    != 0x10);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_status) != 0x14);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_utime)  != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_stime)  != 0x1C);



#ifdef CONFIG_X86_X32_ABI

	CHECK_CSI_OFFSET(_sigchld_x32);

	CHECK_CSI_SIZE  (_sigchld_x32, 7*sizeof(int));

	/* no _sigchld_x32 in the generic siginfo_t */

	BUILD_BUG_ON(offsetof(compat_siginfo_t, _sifields._sigchld_x32._utime)  != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, _sifields._sigchld_x32._stime)  != 0x20);

#endif



	CHECK_CSI_OFFSET(_sigfault);

	CHECK_CSI_SIZE  (_sigfault, 4*sizeof(int));

	CHECK_SI_SIZE   (_sigfault, 8*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_addr) != 0x10);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_addr) != 0x0C);



	BUILD_BUG_ON(offsetof(siginfo_t, si_trapno) != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_trapno) != 0x10);



	BUILD_BUG_ON(offsetof(siginfo_t, si_addr_lsb) != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_addr_lsb) != 0x10);



	BUILD_BUG_ON(offsetof(siginfo_t, si_lower) != 0x20);

	BUILD_BUG_ON(offsetof(siginfo_t, si_upper) != 0x28);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_lower) != 0x14);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_upper) != 0x18);



	BUILD_BUG_ON(offsetof(siginfo_t, si_pkey) != 0x20);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_pkey) != 0x14);



	BUILD_BUG_ON(offsetof(siginfo_t, si_perf_data) != 0x18);

	BUILD_BUG_ON(offsetof(siginfo_t, si_perf_type) != 0x20);

	BUILD_BUG_ON(offsetof(siginfo_t, si_perf_flags) != 0x24);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_perf_data) != 0x10);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_perf_type) != 0x14);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_perf_flags) != 0x18);



	CHECK_CSI_OFFSET(_sigpoll);

	CHECK_CSI_SIZE  (_sigpoll, 2*sizeof(int));

	CHECK_SI_SIZE   (_sigpoll, 4*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_band)   != 0x10);

	BUILD_BUG_ON(offsetof(siginfo_t, si_fd)     != 0x18);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_band) != 0x0C);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_fd)   != 0x10);



	CHECK_CSI_OFFSET(_sigsys);

	CHECK_CSI_SIZE  (_sigsys, 3*sizeof(int));

	CHECK_SI_SIZE   (_sigsys, 4*sizeof(int));



	BUILD_BUG_ON(offsetof(siginfo_t, si_call_addr) != 0x10);

	BUILD_BUG_ON(offsetof(siginfo_t, si_syscall)   != 0x18);

	BUILD_BUG_ON(offsetof(siginfo_t, si_arch)      != 0x1C);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_call_addr) != 0x0C);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_syscall)   != 0x10);

	BUILD_BUG_ON(offsetof(compat_siginfo_t, si_arch)      != 0x14);



	/* any new si_fields should be added here */

}



void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact)

{

	signal_compat_build_tests();



	if (!act)

		return;



	if (in_ia32_syscall())

		act->sa.sa_flags |= SA_IA32_ABI;

	if (in_x32_syscall())

		act->sa.sa_flags |= SA_X32_ABI;

}