arm64: expose FAR_EL1 tag bits in siginfo
Subsystems (5)
v17 cover arm64: expose FAR_EL1 tag bits in siginfo
The kernel currently clears the tag bits (i.e. bits 56-63) in the fault address exposed via siginfo.si_addr and sigcontext.fault_address. However, the tag bits may be needed by tools in order to accurately diagnose memory errors, such as HWASan [1] or future tools based on the Memory Tagging Extension (MTE).
We should not stop clearing these bits in the existing fault address fields, because there may be existing userspace applications that are expecting the tag bits to be cleared. Instead, introduce a flag in sigaction.sa_flags, SA_EXPOSE_TAGBITS, and only expose the tag bits there if the signal handler has this flag set.
In order to allow userspace to determine whether SA_EXPOSE_TAGBITS is supported, we first introduce a mechanism for userspace to detect kernel support for SA_* flags.
These patches need to be applied on top of:
https://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace.git signal-for-v5.11
The series can be viewed on Gerrit here:
https://linux-review.googlesource.com/id/Ia8876bad8c798e0a32df7c2ce1256c4771c81446
[1] http://clang.llvm.org/docs/HardwareAssistedAddressSanitizerDesign.html
Peter Collingbourne (3):
arch: provide better documentation for the arch-specific SA_* flags
signal: define the SA_UNSUPPORTED bit in sa_flags
arm64: expose FAR_EL1 tag bits in siginfo
Documentation/arm64/tagged-pointers.rst | 25 ++++++--- arch/arm64/include/asm/exception.h | 2 +- arch/arm64/include/asm/signal.h | 25 +++++++++ arch/arm64/include/asm/system_misc.h | 2 +- arch/arm64/include/asm/traps.h | 6 +-- arch/arm64/kernel/debug-monitors.c | 5 +- arch/arm64/kernel/entry-common.c | 2 - arch/arm64/kernel/ptrace.c | 7 +-- arch/arm64/kernel/sys_compat.c | 5 +- arch/arm64/kernel/traps.c | 29 ++++++----- arch/arm64/mm/fault.c | 68 ++++++++++++++----------- include/linux/signal.h | 14 +++++ include/linux/signal_types.h | 2 +- include/uapi/asm-generic/signal-defs.h | 32 +++++++++--- kernel/signal.c | 29 ++++++++--- 15 files changed, 168 insertions(+), 85 deletions(-) create mode 100644 arch/arm64/include/asm/signal.h
Signature · 1 line
2.29.2.299.gdc1121823c-goog
PATCH v17 1/3 arch: provide better documentation for the arch-specific SA_* flags
Instead of documenting the arch-specific flag values in a comment at the top where they may be easily overlooked, document them in comments inline with the definitions in numerical order so that it is clear why specific values must be chosen for new generic flags and to reduce the likelihood of conflicts between generic and arch-specific flags.
--- include/uapi/asm-generic/signal-defs.h | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-)
include/uapi/asm-generic/signal-defs.h +14 -8
@@ -17,9 +17,6 @@* * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single * Unix names RESETHAND and NODEFER respectively. -* -* The following bits are used in architecture-specific SA_* definitions and -* should be avoided for new generic flags: 3, 4, 5, 6, 7, 8, 9, 16, 24, 25, 26. */ #ifndef SA_NOCLDSTOP #define SA_NOCLDSTOP 0x00000001
@@ -30,6 +27,20 @@#ifndef SA_SIGINFO #define SA_SIGINFO 0x00000004#endif +/* 0x00000008 used on alpha, mips, parisc */ +/* 0x00000010 used on alpha, parisc */ +/* 0x00000020 used on alpha, parisc, sparc */ +/* 0x00000040 used on alpha, parisc */ +/* 0x00000080 used on parisc */ +/* 0x00000100 used on sparc */ +/* 0x00000200 used on sparc */ +/* 0x00010000 used on mips */ +/* 0x01000000 used on x86 */ +/* 0x02000000 used on x86 */ +/* +* New architectures should not define the obsolete +* SA_RESTORER 0x04000000 +*/ #ifndef SA_ONSTACK #define SA_ONSTACK 0x08000000#endif
@@ -46,11 +57,6 @@#define SA_NOMASK SA_NODEFER#define SA_ONESHOT SA_RESETHAND -/* -* New architectures should not define the obsolete -* SA_RESTORER 0x04000000 -*/ -#ifndef SIG_BLOCK #define SIG_BLOCK 0/* for blocking signals */ #endif
Signature · 1 line
2.29.2.299.gdc1121823c-goog
PATCH v17 2/3 signal: define the SA_UNSUPPORTED bit in sa_flags
In reply to Peter CollingbourneDefine a sa_flags bit, SA_UNSUPPORTED, which will never be supported in the uapi. The purpose of this flag bit is to allow userspace to distinguish an old kernel that does not clear unknown sa_flags bits from a kernel that supports every flag bit.
In other words, if userspace does something like:
act.sa_flags |= SA_UNSUPPORTED; sigaction(SIGSEGV, &act, 0); sigaction(SIGSEGV, 0, &oldact);
and finds that SA_UNSUPPORTED remains set in oldact.sa_flags, it means that the kernel cannot be trusted to have cleared unknown flag bits from sa_flags, so no assumptions about flag bit support can be made.
---
v11:
- clarify the commit message
include/uapi/asm-generic/signal-defs.h | 7 +++++++ kernel/signal.c | 6 ++++++ 2 files changed, 13 insertions(+)
include/uapi/asm-generic/signal-defs.h +7 -0
@@ -14,6 +14,12 @@* SA_RESTART flag to get restarting signals (which were the default long ago) * SA_NODEFER prevents the current signal from being masked in the handler. * SA_RESETHAND clears the handler when the signal is delivered. +* SA_UNSUPPORTED is a flag bit that will never be supported. Kernels from +* before the introduction of SA_UNSUPPORTED did not clear unknown bits from +* sa_flags when read using the oldact argument to sigaction and rt_sigaction, +* so this bit allows flag bit support to be detected from userspace while +* allowing an old kernel to be distinguished from a kernel that supports every +* flag bit. * * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single * Unix names RESETHAND and NODEFER respectively.
@@ -34,6 +40,7 @@/* 0x00000080 used on parisc */ /* 0x00000100 used on sparc */ /* 0x00000200 used on sparc */ +#define SA_UNSUPPORTED 0x00000400/* 0x00010000 used on mips */ /* 0x01000000 used on x86 */ /* 0x02000000 used on x86 */
kernel/signal.c +6 -0
@@ -3985,6 +3985,12 @@ int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)if (oact) *oact = *k; +/* +* Make sure that we never accidentally claim to support SA_UNSUPPORTED, +* e.g. by having an architecture use the bit in their uapi. +*/ +BUILD_BUG_ON (UAPI_SA_FLAGS &SA_UNSUPPORTED ); +/* * Clear unknown flag bits in order to allow userspace to detect missing * support for flag bits and to allow the kernel to use non-uapi bits
Signature · 1 line
2.29.2.299.gdc1121823c-goog
PATCH v17 3/3 arm64: expose FAR_EL1 tag bits in siginfo
In reply to Peter CollingbourneThe kernel currently clears the tag bits (i.e. bits 56-63) in the fault address exposed via siginfo.si_addr and sigcontext.fault_address. However, the tag bits may be needed by tools in order to accurately diagnose memory errors, such as HWASan [1] or future tools based on the Memory Tagging Extension (MTE).
We should not stop clearing these bits in the existing fault address fields, because there may be existing userspace applications that are expecting the tag bits to be cleared. Instead, introduce a flag in sigaction.sa_flags, SA_EXPOSE_TAGBITS, and only expose the tag bits there if the signal handler has this flag set.
[1] http://clang.llvm.org/docs/HardwareAssistedAddressSanitizerDesign.html
---
v16:
- add missing file
v15:
- switched to the SA_EXPOSE_TAGBITS approach
proposed by Eric
- rebased to 5.10-rc3
v14:
- fix an inaccuracy in the commit message
- add some comments to arch_addr_tag_bits_mask
v13:
- renamed si_xflags to si_faultflags
- rebased to 5.10-rc2
v12:
- add new fields to signal_compat.c test cases
- rebased to 5.10-rc1
- mask out bits 63:60 for tag check faults
v11:
- add a comment explaining what the arch hook should do
- rename ignored bits to tag bits
v10:
- rename the flag to SIFAULTFLAG_ADDR_IGNORED_BITS
- use an arch hook to specify which bits are ignored, instead of passing them explicitly
- while refactoring for the arch hook, noticed that my previous patches missed a case involving cache maintenance instructions, so expose the tag bits for that signal as well
v9:
- make the ignored bits fields generic
- add some new dependent patches that prepare us to store the field in such a way that userspace can detect their presence
v8:
- rebase onto 5.8rc2
v7:
- switch to a new siginfo field instead of using sigcontext
- merge the patch back into one since the other patches are now unnecessary
v6:
- move fault address and fault code into the kernel_siginfo data structure
- split the patch in three since it was getting large and now has generic and arch-specific parts
v5:
- add padding to fault_addr_top_byte_context in order to ensure the correct size and preserve sp alignment
v4:
- expose only the tag bits in the context instead of the entire FAR_EL1
- remove mention of the new context from the sigcontext.__reserved[] note
v3:
- add documentation to tagged-pointers.rst
- update comments in sigcontext.h
v2:
- revert changes to hw_breakpoint.c
- rename set_thread_esr to set_thread_far_esr
Documentation/arm64/tagged-pointers.rst | 25 ++++++--- arch/arm64/include/asm/exception.h | 2 +- arch/arm64/include/asm/signal.h | 25 +++++++++ arch/arm64/include/asm/system_misc.h | 2 +- arch/arm64/include/asm/traps.h | 6 +-- arch/arm64/kernel/debug-monitors.c | 5 +- arch/arm64/kernel/entry-common.c | 2 - arch/arm64/kernel/ptrace.c | 7 +-- arch/arm64/kernel/sys_compat.c | 5 +- arch/arm64/kernel/traps.c | 29 ++++++----- arch/arm64/mm/fault.c | 68 ++++++++++++++----------- include/linux/signal.h | 14 +++++ include/linux/signal_types.h | 2 +- include/uapi/asm-generic/signal-defs.h | 3 ++ kernel/signal.c | 23 ++++++--- 15 files changed, 141 insertions(+), 77 deletions(-) create mode 100644 arch/arm64/include/asm/signal.h
Documentation/arm64/tagged-pointers.rst +19 -6
@@ -53,12 +53,25 @@ visibility. Preserving tags --------------- -Non-zero tags are not preserved when delivering signals. This means that -signal handlers in applications making use of tags cannot rely on the -tag information for user virtual addresses being maintained for fields -inside siginfo_t. One exception to this rule is for signals raised in -response to watchpoint debug exceptions, where the tag information will -be preserved. +When delivering signals, non-zero tags are not preserved in +siginfo.si_addr unless the flag SA_EXPOSE_TAGBITS was set in +sigaction.sa_flags when the signal handler was installed. This means +that signal handlers in applications making use of tags cannot rely +on the tag information for user virtual addresses being maintained +in these fields unless the flag was set. + +Due to architecture limitations, bits 63:60 of the fault address +are not preserved in response to synchronous tag check faults +(SEGV_MTESERR) even if SA_EXPOSE_TAGBITS was set. Applications should +treat the values of these bits as undefined in order to accommodate +future architecture revisions which may preserve the bits. + +For signals raised in response to watchpoint debug exceptions, the +tag information will be preserved regardless of the SA_EXPOSE_TAGBITS +flag setting. + +Non-zero tags are never preserved in sigcontext.fault_address +regardless of the SA_EXPOSE_TAGBITS flag setting. The architecture prevents the use of a tagged PC, so the upper byte will be set to a sign-extension of bit 55 on exception return.
arch/arm64/include/asm/exception.h +1 -1
@@ -32,7 +32,7 @@ static inline u32 disr_to_esr(u64 disr) } asmlinkage void enter_from_user_mode(void); -void do_mem_abort (unsigned long addr,unsigned int esr,struct pt_regs *regs); +void do_mem_abort (unsigned long far,unsigned int esr,struct pt_regs *regs);void do_undefinstr (struct pt_regs *regs);void do_bti (struct pt_regs *regs); asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr);
arch/arm64/include/asm/signal.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ARM64_ASM_SIGNAL_H +#define __ARM64_ASM_SIGNAL_H + +#include <asm/memory.h> +#include <uapi/asm/signal.h> +#include <uapi/asm/siginfo.h> + +static inline void __user *arch_untagged_si_addr (void __user *addr, +unsigned long sig, +unsigned long si_code) +{ +/* +* For historical reasons, all bits of the fault address are exposed as +* address bits for watchpoint exceptions. New architectures should +* handle the tag bits consistently. +*/ +if (sig ==SIGTRAP && si_code ==TRAP_BRKPT ) +return addr; + +return untagged_addr (addr); +} +#define arch_untagged_si_addr arch_untagged_si_addr + +#endif
arch/arm64/include/asm/system_misc.h +1 -1
@@ -22,7 +22,7 @@ void die(const char *msg, struct pt_regs *regs, int err);struct siginfo ;void arm64_notify_die (const char *str,struct pt_regs *regs, -int signo,int sicode,void __user *addr, +int signo,int sicode,unsigned long far,int err); void hook_debug_fault_code(int nr, int (*fn)(unsigned long, unsigned int,
arch/arm64/include/asm/traps.h +3 -3
@@ -26,9 +26,9 @@ void register_undef_hook(struct undef_hook *hook);void unregister_undef_hook (struct undef_hook *hook);void force_signal_inject (int signal,int code,unsigned long address,unsigned int err);void arm64_notify_segfault (unsigned long addr); -void arm64_force_sig_fault (int signo,int code,void __user *addr,const char *str); -void arm64_force_sig_mceerr (int code,void __user *addr,short lsb,const char *str); -void arm64_force_sig_ptrace_errno_trap (int errno,void __user *addr,const char *str); +void arm64_force_sig_fault (int signo,int code,unsigned long far,const char *str); +void arm64_force_sig_mceerr (int code,unsigned long far,short lsb,const char *str); +void arm64_force_sig_ptrace_errno_trap (int errno,unsigned long far,const char *str);/* * Move regs->pc to next instruction and do necessary setup before it
arch/arm64/kernel/debug-monitors.c +2 -3
@@ -234,9 +234,8 @@ static void send_user_sigtrap(int si_code)if (interrupts_enabled (regs))local_irq_enable (); -arm64_force_sig_fault (SIGTRAP , si_code, - (void __user *)instruction_pointer (regs), -"User debug trap" ); +arm64_force_sig_fault (SIGTRAP , si_code,instruction_pointer (regs), +"User debug trap" ); } static int single_step_handler(unsigned long unused, unsigned int esr,
arch/arm64/kernel/entry-common.c +0 -2
@@ -22,7 +22,6 @@ static void notrace el1_abort(struct pt_regs *regs, unsigned long esr)unsigned long far =read_sysreg (far_el1);local_daif_inherit (regs); - far =untagged_addr (far);do_mem_abort (far, esr, regs); }NOKPROBE_SYMBOL (el1_abort);
@@ -114,7 +113,6 @@ static void notrace el0_da(struct pt_regs *regs, unsigned long esr)user_exit_irqoff ();local_daif_restore (DAIF_PROCCTX ); - far =untagged_addr (far);do_mem_abort (far, esr, regs); }NOKPROBE_SYMBOL (el0_da);
arch/arm64/kernel/ptrace.c +2 -5
@@ -192,14 +192,11 @@ static void ptrace_hbptriggered(struct perf_event *bp, break; } } -arm64_force_sig_ptrace_errno_trap (si_errno, - (void __user *)bkpt->trigger, +arm64_force_sig_ptrace_errno_trap (si_errno, bkpt->trigger, desc); }#endif -arm64_force_sig_fault (SIGTRAP ,TRAP_HWBKPT , - (void __user *)(bkpt->trigger), - desc); +arm64_force_sig_fault (SIGTRAP ,TRAP_HWBKPT , bkpt->trigger, desc); }/*
arch/arm64/kernel/sys_compat.c +2 -3
@@ -68,7 +68,7 @@ do_compat_cache_op(unsigned long start, unsigned long end, int flags)*/ long compat_arm_syscall (struct pt_regs *regs,int scno) { -void __user *addr; +unsigned long addr;switch (scno) {/*
@@ -111,8 +111,7 @@ long compat_arm_syscall(struct pt_regs *regs, int scno)break ; } - addr = (void __user *)instruction_pointer (regs) - - (compat_thumb_mode (regs) ?2 :4 ); + addr =instruction_pointer (regs) - (compat_thumb_mode (regs) ?2 :4 );arm64_notify_die ("Oops - bad compat syscall(2)" , regs,SIGILL ,ILL_ILLTRP , addr, scno);
arch/arm64/kernel/traps.c +15 -14
@@ -170,32 +170,32 @@ static void arm64_show_signal(int signo, const char *str)__show_regs (regs); } -void arm64_force_sig_fault (int signo,int code,void __user *addr, +void arm64_force_sig_fault (int signo,int code,unsigned long far,const char *str) {arm64_show_signal (signo, str);if (signo ==SIGKILL )force_sig (SIGKILL );else -force_sig_fault (signo, code, addr); +force_sig_fault (signo, code, (void __user *)far); } -void arm64_force_sig_mceerr (int code,void __user *addr,short lsb, +void arm64_force_sig_mceerr (int code,unsigned long far,short lsb,const char *str) {arm64_show_signal (SIGBUS , str); -force_sig_mceerr (code, addr, lsb); +force_sig_mceerr (code, (void __user *)far, lsb); } -void arm64_force_sig_ptrace_errno_trap (int errno,void __user *addr, +void arm64_force_sig_ptrace_errno_trap (int errno,unsigned long far,const char *str) {arm64_show_signal (SIGTRAP , str); -force_sig_ptrace_errno_trap (errno, addr); +force_sig_ptrace_errno_trap (errno, (void __user *)far); }void arm64_notify_die (const char *str,struct pt_regs *regs, -int signo,int sicode,void __user *addr, +int signo,int sicode,unsigned long far,int err) {if (user_mode (regs)) {
@@ -203,7 +203,7 @@ void arm64_notify_die(const char *str, struct pt_regs *regs, current->thread.fault_address =0 ; current->thread.fault_code = err; -arm64_force_sig_fault (signo, sicode, addr, str); +arm64_force_sig_fault (signo, sicode, far, str); }else {die (str, regs, err); }
@@ -374,7 +374,7 @@ void force_signal_inject(int signal, int code, unsigned long address, unsigned i signal =SIGKILL ; } -arm64_notify_die (desc, regs, signal, code, (void __user *)address, err); +arm64_notify_die (desc, regs, signal, code, address, err); }/*
@@ -385,7 +385,7 @@ void arm64_notify_segfault(unsigned long addr)int code;mmap_read_lock (current->mm); -if (find_vma (current->mm, addr) ==NULL ) +if (find_vma (current->mm,untagged_addr (addr)) ==NULL ) code =SEGV_MAPERR ;else code =SEGV_ACCERR ;
@@ -448,12 +448,13 @@ NOKPROBE_SYMBOL(do_ptrauth_fault);static void user_cache_maint_handler (unsigned int esr,struct pt_regs *regs) { -unsigned long address; +unsigned long tagged_address, address;int rt =ESR_ELx_SYS64_ISS_RT (esr);int crm = (esr & ESR_ELx_SYS64_ISS_CRM_MASK) >> ESR_ELx_SYS64_ISS_CRM_SHIFT;int ret =0 ; - address =untagged_addr (pt_regs_read_reg (regs, rt)); + tagged_address =pt_regs_read_reg (regs, rt); + address =untagged_addr (tagged_address);switch (crm) {case ESR_ELx_SYS64_ISS_CRM_DC_CVAU:/* DC CVAU, gets promoted */
@@ -480,7 +481,7 @@ static void user_cache_maint_handler(unsigned int esr, struct pt_regs *regs) }if (ret) -arm64_notify_segfault (address); +arm64_notify_segfault (tagged_address);else arm64_skip_faulting_instruction (regs,AARCH64_INSN_SIZE ); }
@@ -772,7 +773,7 @@ asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr)*/ void bad_el0_sync (struct pt_regs *regs,int reason,unsigned int esr) { -void __user *pc = (void __user *)instruction_pointer (regs); +unsigned long pc =instruction_pointer (regs); current->thread.fault_address =0 ; current->thread.fault_code = esr;
arch/arm64/mm/fault.c +37 -31
183 lines not on this page · raw message
include/linux/signal.h +14 -0
@@ -469,4 +469,18 @@ struct seq_file;extern void render_sigset_t (struct seq_file *,const char *,sigset_t *);#endif +#ifndef arch_untagged_si_addr +/* +* Given a fault address and a signal and si_code which correspond to the +* _sigfault union member, returns the address that must appear in si_addr if +* the signal handler does not have SA_EXPOSE_TAGBITS enabled in sa_flags. +*/ +static inline void __user *arch_untagged_si_addr (void __user *addr, +unsigned long sig, +unsigned long si_code) +{ +return addr; +} +#endif +#endif /* _LINUX_SIGNAL_H */
include/linux/signal_types.h +1 -1
@@ -78,6 +78,6 @@ struct ksignal {#define UAPI_SA_FLAGS \ (SA_NOCLDSTOP | SA_NOCLDWAIT | SA_SIGINFO | SA_ONSTACK | SA_RESTART | \ - SA_NODEFER | SA_RESETHAND | __ARCH_UAPI_SA_FLAGS) + SA_NODEFER | SA_RESETHAND | SA_EXPOSE_TAGBITS | __ARCH_UAPI_SA_FLAGS)#endif /* _LINUX_SIGNAL_TYPES_H */
include/uapi/asm-generic/signal-defs.h +3 -0
@@ -20,6 +20,8 @@* so this bit allows flag bit support to be detected from userspace while * allowing an old kernel to be distinguished from a kernel that supports every * flag bit. +* SA_EXPOSE_TAGBITS exposes an architecture-defined set of tag bits in +* siginfo.si_addr. * * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single * Unix names RESETHAND and NODEFER respectively.
@@ -41,6 +43,7 @@/* 0x00000100 used on sparc */ /* 0x00000200 used on sparc */ #define SA_UNSUPPORTED 0x00000400 +#define SA_EXPOSE_TAGBITS 0x00000800/* 0x00010000 used on mips */ /* 0x01000000 used on x86 */ /* 0x02000000 used on x86 */
kernel/signal.c +16 -7
@@ -1650,6 +1650,15 @@ void force_sigsegv(int sig)force_sig (SIGSEGV ); } +static void __user *get_si_addr (void __user *addr,unsigned long sig, +unsigned long si_code) +{ +if (current->sighand->action[sig -1 ].sa.sa_flags &SA_EXPOSE_TAGBITS ) +return addr; + +return arch_untagged_si_addr (addr, sig, si_code); +} + int force_sig_fault_to_task(int sig, int code, void __user *addr___ARCH_SI_TRAPNO (int trapno) ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
@@ -1661,7 +1670,7 @@ int force_sig_fault_to_task(int sig, int code, void __user *addr info.si_signo = sig; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr, sig, code);#ifdef __ARCH_SI_TRAPNO info.si_trapno = trapno;#endif
@@ -1693,7 +1702,7 @@ int send_sig_fault(int sig, int code, void __user *addr info.si_signo = sig; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr, sig, code);#ifdef __ARCH_SI_TRAPNO info.si_trapno = trapno;#endif
@@ -1714,7 +1723,7 @@ int force_sig_mceerr(int code, void __user *addr, short lsb) info.si_signo =SIGBUS ; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGBUS , code); info.si_addr_lsb = lsb;return force_sig_info (&info); }
@@ -1728,7 +1737,7 @@ int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct * info.si_signo =SIGBUS ; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGBUS , code); info.si_addr_lsb = lsb;return send_sig_info (info.si_signo, &info, t); }
@@ -1742,7 +1751,7 @@ int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper) info.si_signo =SIGSEGV ; info.si_errno =0 ; info.si_code =SEGV_BNDERR ; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGSEGV ,SEGV_BNDERR ); info.si_lower = lower; info.si_upper = upper;return force_sig_info (&info);
@@ -1757,7 +1766,7 @@ int force_sig_pkuerr(void __user *addr, u32 pkey) info.si_signo =SIGSEGV ; info.si_errno =0 ; info.si_code =SEGV_PKUERR ; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGSEGV ,SEGV_PKUERR ); info.si_pkey = pkey;return force_sig_info (&info); }
@@ -1774,7 +1783,7 @@ int force_sig_ptrace_errno_trap(int errno, void __user *addr) info.si_signo =SIGTRAP ; info.si_errno = errno; info.si_code =TRAP_HWBKPT ; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGTRAP ,TRAP_HWBKPT );return force_sig_info (&info); }
Signature · 1 line
2.29.2.299.gdc1121823c-goog
kernel/signal.c void force_sigsegv(int sig) · line 1657
Quoted 13 lines · Peter Collingbourne
kernel/signal.c +5
-0@@ -1650,6 +1650,15 @@ void force_sigsegv(int sig)force_sig (SIGSEGV ); } +static void __user *get_si_addr (void __user *addr,unsigned long sig, +unsigned long si_code) +{ +if (current->sighand->action[sig -1 ].sa.sa_flags &SA_EXPOSE_TAGBITS ) +return addr;
Apologies for not seeing this before but this part of the patch is buggy.
It is using current->sighand->action when the destination task may not be current. send_sig_fault and send_sig_mcerr may somewhat legitimately be used to send faults to other processes.
Now that I think about it there are interactions with PTRACE_GETSIGINFO/PTRACE_SETSIGINFO.
Can we move the masking into get_signal after the ptrace handling?
That way everything in the core of the kernel deals with unmasked si_addr values and we only mask the address just before sending it to userspace?
Eric
Quoted 61 lines
kernel/signal.c +9
-6+return arch_untagged_si_addr (addr, sig, si_code); +} + int force_sig_fault_to_task(int sig, int code, void __user *addr___ARCH_SI_TRAPNO (int trapno) ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)@@ -1661,7 +1670,7 @@ int force_sig_fault_to_task(int sig, int code, void __user *addr info.si_signo = sig; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr, sig, code);#ifdef __ARCH_SI_TRAPNO info.si_trapno = trapno;#endif @@ -1693,7 +1702,7 @@ int send_sig_fault(int sig, int code, void __user *addr info.si_signo = sig; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr, sig, code);#ifdef __ARCH_SI_TRAPNO info.si_trapno = trapno;#endif @@ -1714,7 +1723,7 @@ int force_sig_mceerr(int code, void __user *addr, short lsb) info.si_signo =SIGBUS ; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGBUS , code); info.si_addr_lsb = lsb;return force_sig_info (&info); }@@ -1728,7 +1737,7 @@ int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct * info.si_signo =SIGBUS ; info.si_errno =0 ; info.si_code = code; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGBUS , code); info.si_addr_lsb = lsb;return send_sig_info (info.si_signo, &info, t); }@@ -1742,7 +1751,7 @@ int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper) info.si_signo =SIGSEGV ; info.si_errno =0 ; info.si_code =SEGV_BNDERR ; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGSEGV ,SEGV_BNDERR ); info.si_lower = lower; info.si_upper = upper;return force_sig_info (&info);@@ -1757,7 +1766,7 @@ int force_sig_pkuerr(void __user *addr, u32 pkey) info.si_signo =SIGSEGV ; info.si_errno =0 ; info.si_code =SEGV_PKUERR ; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGSEGV ,SEGV_PKUERR ); info.si_pkey = pkey;return force_sig_info (&info); }
kernel/signal.c int force_sig_ptrace_errno_trap(int errno, void __user *addr) · line 1788
Quoted 7 lines
kernel/signal.c +1
-1@@ -1774,7 +1783,7 @@ int force_sig_ptrace_errno_trap(int errno, void __user *addr) info.si_signo =SIGTRAP ; info.si_errno = errno; info.si_code =TRAP_HWBKPT ; - info.si_addr = addr; + info.si_addr =get_si_addr (addr,SIGTRAP ,TRAP_HWBKPT );return force_sig_info (&info); }
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Quoted 24 lines · Eric W. Biederman
kernel/signal.c void force_sigsegv(int sig) · line 1657
Quoted 13 lines · Peter Collingbourne
kernel/signal.c +5
-0@@ -1650,6 +1650,15 @@ void force_sigsegv(int sig)force_sig (SIGSEGV ); } +static void __user *get_si_addr (void __user *addr,unsigned long sig, +unsigned long si_code) +{ +if (current->sighand->action[sig -1 ].sa.sa_flags &SA_EXPOSE_TAGBITS ) +return addr;Apologies for not seeing this before but this part of the patch is buggy.
It is using
current->sighand->actionwhen the destination task may not be current.send_sig_faultandsend_sig_mcerrmay somewhat legitimately be used to send faults to other processes.
Quoted 8 lines
Now that I think about it there are interactions with PTRACE_GETSIGINFO/PTRACE_SETSIGINFO.
Can we move the masking into
get_signalafter the ptrace handling?That way everything in the core of the kernel deals with unmasked
si_addrvalues and we only mask the address just before sending it to userspace?
Makes sense, done in v18.
Peter
Quoted 12 lines · Peter Collingbourne
The kernel currently clears the tag bits (i.e. bits 56-63) in the fault address exposed via siginfo.si_addr and sigcontext.fault_address. However, the tag bits may be needed by tools in order to accurately diagnose memory errors, such as HWASan [1] or future tools based on the Memory Tagging Extension (MTE).
We should not stop clearing these bits in the existing fault address fields, because there may be existing userspace applications that are expecting the tag bits to be cleared. Instead, introduce a flag in sigaction.sa_flags,
SA_EXPOSE_TAGBITS, and only expose the tag bits there if the signal handler has this flag set.
Quoted 6 lines
In order to allow userspace to determine whether
SA_EXPOSE_TAGBITSis supported, we first introduce a mechanism for userspace to detect kernel support for SA_* flags.These patches need to be applied on top of:
https://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace.git signal-for-v5.11
The first two patches look good and I have applied them.
While I was at it I added Link tags to the LKML postings to the entire series. I don't think anyone has merged my branch into another so it should still be safe.
Eric
Quoted 19 lines · Eric W. Biederman
Quoted 16 lines · Peter Collingbourne
The kernel currently clears the tag bits (i.e. bits 56-63) in the fault address exposed via siginfo.si_addr and sigcontext.fault_address. However, the tag bits may be needed by tools in order to accurately diagnose memory errors, such as HWASan [1] or future tools based on the Memory Tagging Extension (MTE).
We should not stop clearing these bits in the existing fault address fields, because there may be existing userspace applications that are expecting the tag bits to be cleared. Instead, introduce a flag in sigaction.sa_flags,
SA_EXPOSE_TAGBITS, and only expose the tag bits there if the signal handler has this flag set.In order to allow userspace to determine whether
SA_EXPOSE_TAGBITSis supported, we first introduce a mechanism for userspace to detect kernel support for SA_* flags.
Quoted 8 lines
Quoted 2 lines
These patches need to be applied on top of:
https://git.kernel.org/pub/scm/linux/kernel/git/ebiederm/user-namespace.git signal-for-v5.11The first two patches look good and I have applied them.
While I was at it I added Link tags to the LKML postings to the entire series. I don't think anyone has merged my branch into another so it should still be safe.
Thanks!
Peter