x86/insn-eval: Add support for 64-bit kernel mode
Subsystems (6)
PATCH v4 1/4 x86/insn-eval: Add support for 64-bit kernel mode
To support evaluating 64-bit kernel mode instructions:
Replace existing checks for user_64bit_mode() with a new helper that checks whether code is being executed in either 64-bit kernel mode or 64-bit user mode.
Select the GS base depending on whether the instruction is being evaluated in kernel mode.
---
Notes:
v2:
no changes
v3:
no changes
v4:
no changesarch/x86/include/asm/ptrace.h | 13 +++++++++++++ arch/x86/lib/insn-eval.c | 26 +++++++++++++++----------- 2 files changed, 28 insertions(+), 11 deletions(-)
arch/x86/include/asm/ptrace.h +13 -0
@@ -159,6 +159,19 @@ static inline bool user_64bit_mode(struct pt_regs *regs)#endif } +/* +* Determine whether the register set came from any context that is running in +* 64-bit mode. +*/ +static inline bool any_64bit_mode (struct pt_regs *regs) +{ +#ifdef CONFIG_X86_64 +return !user_mode (regs) ||user_64bit_mode (regs); +#else +return false; +#endif +} +#ifdef CONFIG_X86_64 #define current_user_stack_pointer () current_pt_regs()->sp#define compat_user_stack_pointer () current_pt_regs()->sp
arch/x86/lib/insn-eval.c +15 -11
@@ -155,7 +155,7 @@ static bool check_seg_overrides(struct insn *insn, int regoff)*/ static int resolve_default_seg (struct insn *insn,struct pt_regs *regs,int off) { -if (user_64bit_mode (regs)) +if (any_64bit_mode (regs))return INAT_SEG_REG_IGNORE ;/* * Resolve the default segment register as described in Section 3.7.4
@@ -266,7 +266,7 @@ static int resolve_seg_reg(struct insn *insn, struct pt_regs *regs, int regoff)* which may be invalid at this point. */ if (regoff == offsetof(struct pt_regs , ip)) { -if (user_64bit_mode (regs)) +if (any_64bit_mode (regs))return INAT_SEG_REG_IGNORE ;else return INAT_SEG_REG_CS ;
@@ -289,7 +289,7 @@ static int resolve_seg_reg(struct insn *insn, struct pt_regs *regs, int regoff)* In long mode, segment override prefixes are ignored, except for * overrides for FS and GS. */ -if (user_64bit_mode (regs)) { +if (any_64bit_mode (regs)) {if (idx !=INAT_SEG_REG_FS && idx !=INAT_SEG_REG_GS ) idx =INAT_SEG_REG_IGNORE ;
@@ -646,23 +646,27 @@ unsigned long insn_get_seg_base(struct pt_regs *regs, int seg_reg_idx)*/ return (unsigned long )(sel <<4 ); -if (user_64bit_mode (regs)) { +if (any_64bit_mode (regs)) {/* * Only FS or GS will have a base address, the rest of * the segments' bases are forced to 0. */ unsigned long base; -if (seg_reg_idx ==INAT_SEG_REG_FS ) +if (seg_reg_idx ==INAT_SEG_REG_FS ) {rdmsrl (MSR_FS_BASE , base); -else if (seg_reg_idx ==INAT_SEG_REG_GS ) + }else if (seg_reg_idx ==INAT_SEG_REG_GS ) {/* * swapgs was called at the kernel entry point. Thus, * MSR_KERNEL_GS_BASE will have the user-space GS base. */ -rdmsrl (MSR_KERNEL_GS_BASE , base); -else +if (user_mode (regs)) +rdmsrl (MSR_KERNEL_GS_BASE , base); +else +rdmsrl (MSR_GS_BASE , base); + }else { base =0 ; + }return base; }
@@ -703,7 +707,7 @@ static unsigned long get_seg_limit(struct pt_regs *regs, int seg_reg_idx)if (sel <0 )return 0 ; -if (user_64bit_mode (regs) ||v8086_mode (regs)) +if (any_64bit_mode (regs) ||v8086_mode (regs))return -1L ;if (!sel)
@@ -948,7 +952,7 @@ static int get_eff_addr_modrm(struct insn *insn, struct pt_regs *regs,* following instruction. */ if (*regoff == -EDOM ) { -if (user_64bit_mode (regs)) +if (any_64bit_mode (regs)) tmp = regs->ip + insn->length;else tmp =0 ;
@@ -1250,7 +1254,7 @@ static void __user *get_addr_ref_32(struct insn *insn, struct pt_regs *regs)* After computed, the effective address is treated as an unsigned * quantity. */ -if (!user_64bit_mode (regs) && ((unsigned int )eff_addr > seg_limit)) +if (!any_64bit_mode (regs) && ((unsigned int )eff_addr > seg_limit)) goto out;/*
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
PATCH v4 2/4 x86/traps: Print non-canonical address on #GP
A frequent cause of #GP exceptions are memory accesses to non-canonical addresses. Unlike #PF, #GP doesn't come with a fault address in CR2, so the kernel doesn't currently print the fault address for #GP. Luckily, we already have the necessary infrastructure for decoding X86 instructions and computing the memory address that is being accessed; hook it up to the #GP handler so that we can figure out whether the #GP looks like it was caused by a non-canonical address, and if so, print that address.
While it is already possible to compute the faulting address manually by disassembling the opcode dump and evaluating the instruction against the register dump, this should make it slightly easier to identify crashes at a glance.
---
Notes:
v2:
- print different message for segment-related GP (Borislav)
- rewrite check for non-canonical address (Sean)
- make it clear we don't know for sure why the GP happened (Andy)
v3:
- change message format to one line (Borislav)
v4:
- rename insn_bytes to insn_buf (Ingo)
- add space after GPFSTR (Ingo)
- make sizeof(desc) clearer (Ingo, Borislav)
- also print the address (with a different message) if it's canonical (Ingo)
I have already sent a patch to syzkaller that relaxes their parsing of GPF messages (https://github.com/google/syzkaller/commit/432c7650) such that changes like the one in this patch don't break it.
That patch has already made its way into syzbot's syzkaller instances according to <https://syzkaller.appspot.com/upstream>.
arch/x86/kernel/traps.c | 64 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 61 insertions(+), 3 deletions(-)
arch/x86/kernel/traps.c +61 -3
@@ -56,6 +56,8 @@#include <asm/mpx.h> #include <asm/vm86.h> #include <asm/umip.h> +#include <asm/insn.h> +#include <asm/insn-eval.h> #ifdef CONFIG_X86_64 #include <asm/x86_init.h>
@@ -509,11 +511,50 @@ dotraplinkage void do_bounds(struct pt_regs *regs, long error_code)do_trap (X86_TRAP_BR ,SIGSEGV ,"bounds" , regs, error_code,0 ,NULL ); } +/* +* On 64-bit, if an uncaught #GP occurs while dereferencing a non-canonical +* address, return that address. +*/ +static bool get_kernel_gp_address (struct pt_regs *regs,unsigned long *addr, +bool *non_canonical) +{ +#ifdef CONFIG_X86_64 +u8 insn_buf[MAX_INSN_SIZE ]; +struct insn insn; + +if (probe_kernel_read (insn_buf, (void *)regs->ip,MAX_INSN_SIZE )) +return false; + +kernel_insn_init (&insn, insn_buf,MAX_INSN_SIZE ); +insn_get_modrm (&insn); +insn_get_sib (&insn); + *addr = (unsigned long )insn_get_addr_ref (&insn, regs); + +if (*addr == (unsigned long )-1L ) +return false; + +/* +* Check that: +* - the address is not in the kernel half or -1 (which means the +* decoder failed to decode it) +* - the last byte of the address is not in the user canonical half +*/ + *non_canonical = *addr < ~__VIRTUAL_MASK && + *addr + insn.opnd_bytes -1 > __VIRTUAL_MASK; + +return true; +#else +return false; +#endif +} + +#define GPFSTR "general protection fault" + dotraplinkage voiddo_general_protection (struct pt_regs *regs,long error_code) { -const char *desc ="general protection fault" ;struct task_struct *tsk; +char desc[sizeof (GPFSTR ) +50 +2 *sizeof (unsigned long ) +1 ] =GPFSTR ;RCU_LOCKDEP_WARN (!rcu_is_watching (),"entry code didn't wake RCU" );cond_local_irq_enable (regs);
@@ -531,6 +572,10 @@ do_general_protection(struct pt_regs *regs, long error_code) tsk = current;if (!user_mode (regs)) { +bool addr_resolved = false; +unsigned long gp_addr; +bool non_canonical; +if (fixup_exception (regs,X86_TRAP_GP , error_code,0 ))return ;
@@ -547,8 +592,21 @@ do_general_protection(struct pt_regs *regs, long error_code)return ;if (notify_die (DIE_GPF , desc, regs, error_code, -X86_TRAP_GP ,SIGSEGV ) !=NOTIFY_STOP ) -die (desc, regs, error_code); +X86_TRAP_GP ,SIGSEGV ) ==NOTIFY_STOP ) +return ; + +if (error_code) +snprintf (desc,sizeof (desc),"segment-related " GPFSTR ); +else + addr_resolved =get_kernel_gp_address (regs, &gp_addr, + &non_canonical); + +if (addr_resolved) +snprintf (desc,sizeof (desc), +GPFSTR " probably for %saddress 0x%lx" , + non_canonical ?"non-canonical " :"" , gp_addr); + +die (desc, regs, error_code);return ; }
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
Re: [PATCH v4 2/4] x86/traps: Print non-canonical address on #GP
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 516
Quoted 7 lines · Jann Horn
arch/x86/kernel/traps.c +3
-0@@ -509,11 +511,50 @@ dotraplinkage void do_bounds(struct pt_regs *regs, long error_code)do_trap (X86_TRAP_BR ,SIGSEGV ,"bounds" , regs, error_code,0 ,NULL ); } +/* +* On 64-bit, if an uncaught #GP occurs while dereferencing a non-canonical +* address, return that address.
Stale comment now that it's decoding canonical addresses too.
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 519
Quoted 3 lines
arch/x86/kernel/traps.c +3
-0+*/ +static bool get_kernel_gp_address (struct pt_regs *regs,unsigned long *addr, +bool *non_canonical)
Alignment of non_canonical is funky.
Quoted 4 lines
arch/x86/kernel/traps.c +4
-0+{ +#ifdef CONFIG_X86_64 +u8 insn_buf[MAX_INSN_SIZE ]; +struct insn insn;
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 533
Quoted 10 lines
arch/x86/kernel/traps.c +10
-0+ +if (probe_kernel_read (insn_buf, (void *)regs->ip,MAX_INSN_SIZE )) +return false; + +kernel_insn_init (&insn, insn_buf,MAX_INSN_SIZE ); +insn_get_modrm (&insn); +insn_get_sib (&insn); + *addr = (unsigned long )insn_get_addr_ref (&insn, regs); + +if (*addr == (unsigned long )-1L )
Nit, wouldn't -1UL avoid the need to cast?
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 541
Quoted 8 lines
arch/x86/kernel/traps.c +8
-0+return false; + +/* +* Check that: +* - the address is not in the kernel half or -1 (which means the +* decoder failed to decode it) +* - the last byte of the address is not in the user canonical half +*/
This -1 part of the comment should be moved above, or probably dropped entirely.
Quoted 40 lines
arch/x86/kernel/traps.c +19
-3+ *non_canonical = *addr < ~__VIRTUAL_MASK && + *addr + insn.opnd_bytes -1 > __VIRTUAL_MASK; + +return true; +#else +return false; +#endif +} + +#define GPFSTR "general protection fault" + dotraplinkage voiddo_general_protection (struct pt_regs *regs,long error_code) { -const char *desc ="general protection fault" ;struct task_struct *tsk; +char desc[sizeof (GPFSTR ) +50 +2 *sizeof (unsigned long ) +1 ] =GPFSTR ;RCU_LOCKDEP_WARN (!rcu_is_watching (),"entry code didn't wake RCU" );cond_local_irq_enable (regs);@@ -531,6 +572,10 @@ do_general_protection(struct pt_regs *regs, long error_code) tsk = current;if (!user_mode (regs)) { +bool addr_resolved = false; +unsigned long gp_addr; +bool non_canonical; +if (fixup_exception (regs,X86_TRAP_GP , error_code,0 ))return ;@@ -547,8 +592,21 @@ do_general_protection(struct pt_regs *regs, long error_code)return ;if (notify_die (DIE_GPF , desc, regs, error_code, -X86_TRAP_GP ,SIGSEGV ) !=NOTIFY_STOP ) -die (desc, regs, error_code); +X86_TRAP_GP ,SIGSEGV ) ==NOTIFY_STOP ) +return ; +
arch/x86/kernel/traps.c do_general_protection(struct pt_regs *regs, long error_code) · line 607
Quoted 10 lines
arch/x86/kernel/traps.c +10
-0+if (error_code) +snprintf (desc,sizeof (desc),"segment-related " GPFSTR ); +else + addr_resolved =get_kernel_gp_address (regs, &gp_addr, + &non_canonical); + +if (addr_resolved) +snprintf (desc,sizeof (desc), +GPFSTR " probably for %saddress 0x%lx" , + non_canonical ?"non-canonical " :"" , gp_addr);
I still think not explicitly calling out the straddle case will be confusing, e.g.
general protection fault probably for non-canonical address 0x7fffffffffff: 0000 [#1] SMP
versus
general protection fault, non-canonical access 0x7fffffffffff - 0x800000000006: 0000 [#1] SMP
And for the canonical case, "probably for address" may not be all that accurate, e.g. #GP(0) due to a instruction specific requirement is arguably just as likely to apply to the instruction itself as it is to its memory operand.
Rather than pass around multiple booleans, what about adding an enum and handling everything in (a renamed) get_kernel_gp_address? This works especially well if address decoding is done for 32-bit as well as 64-bit, which is probably worth doing since we're printing the address in 64-bit even if it's canonical. The ifdeffery is really ugly if its 64-bit only...
enum kernel_gp_hint {
GP_NO_HINT,
GP_SEGMENT,
GP_NON_CANONICAL,
GP_STRADDLE_CANONICAL,
GP_RESOLVED_ADDR,
};
static int get_kernel_gp_hint(struct pt_regs *regs, unsigned long error_code,
unsigned long *addr, unsigned char *size)
{
u8 insn_buf[MAX_INSN_SIZE];
struct insn insn;
if (error_code)
return GP_SEGMENT;
if (probe_kernel_read(insn_buf, (void *)regs->ip, MAX_INSN_SIZE))
return false;
kernel_insn_init(&insn, insn_buf, MAX_INSN_SIZE);
insn_get_modrm(&insn);
insn_get_sib(&insn);
*addr = (unsigned long)insn_get_addr_ref(&insn, regs);
*size = insn.opnd_bytes;
if (*addr == -1UL)
return GP_NO_HINT;#ifdef CONFIG_X86_64 if (*addr < ~__VIRTUAL_MASK && *addr > __VIRTUAL_MASK) return GP_NON_CANONICAL; if (*addr < ~__VIRTUAL_MASK && (*addr + *size - 1) > __VIRTUAL_MASK) return GP_STRADDLE_CANONICAL; #endif return GP_RESOLVED_ADDR; }
Then the snprintf sequence can handle each case indvidually.
hint = get_kernel_gp_hint(regs, error_code, &addr, &size); if (hint == GP_SEGMENT) snprintf(desc, sizeof(desc), GPFSTR ", for segment 0x%lx", error_code); else if (hint == GP_NON_CANONICAL) snprintf(desc, sizeof(desc), GPFSTR ", non-canonical address 0x%lx", addr); else if (hint == GP_STRADDLE_CANONICAL) snprintf(desc, sizeof(desc), GPFSTR ", non-canonical access 0x%lx - 0x%lx", addr, addr + size - 1); else if (hint == GP_RESOLVED_ADDR) snprintf(desc, sizeof(desc), GPFSTR ", possibly for access 0x%lx - 0x%lx", addr, addr + size - 1); flags = oops_begin(); sig = SIGSEGV; __die_header(desc, regs, error_code); if (hint == GP_NON_CANONICAL || hint == GP_STRADDLE_CANONICAL) kasan_non_canonical_hook(addr); if (__die_body(desc, regs, error_code)) sig = 0; oops_end(flags, regs, sig); die(desc, regs, error_code);
I get that adding a print just for the straddle case is probably overkill, but it seems silly to add all this and not make it as precise as possible.
general protection fault, non-canonical address 0xdead000000000000: 0000 [#1] SMP general protection fault, non-canonical access 0x7fffffffffff - 0x800000000006: 0000 [#1] SMP general protection fault, possibly for address 0xffffc9000021bd90: 0000 [#1] SMP general protection fault, possibly for address 0xebcbde5c: 0000 [#1] SMP // 32-bit kernel
Side topic, opnd_bytes isn't correct for instructions with fixed 64-bit operands (Mq notation in the opcode map), which is probably an argument against the fancy straddle logic...
Quoted 7 lines
arch/x86/kernel/traps.c +1
-0+die (desc, regs, error_code);return ; }Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
Borislav Petkov
maintainerRe: [PATCH v4 2/4] x86/traps: Print non-canonical address on #GP
Quoted 1 line · Sean Christopherson
I get that adding a print just for the straddle case is probably overkill,
Yes, frankly I am not too crazy about adding all that code just for the straddle case.
Also, the straddle case is kinda clear - it is always the
0x7ffffffffXX.. + size - 1
address and we could simply dump that address instead of dumping a range. So we can simplify this to:
("general protection fault, non-canonical address 0x%lx: 0000 [#1] SMP\n", addr + size - 1)It all depends on how the access is done by the hardware but we can't always be absolutely sure which of the non-canonical bytes was accessed first. Depends also on the access width and yadda yadda... But I don't think we can know for sure always without the hw telling us, thus the "possibly" formulation.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v4 2/4] x86/traps: Print non-canonical address on #GP
In reply to Sean ChristophersonQuoted 10 lines · Sean Christopherson
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 516
Quoted 7 lines · Jann Horn
arch/x86/kernel/traps.c +3
-0@@ -509,11 +511,50 @@ dotraplinkage void do_bounds(struct pt_regs *regs, long error_code)do_trap (X86_TRAP_BR ,SIGSEGV ,"bounds" , regs, error_code,0 ,NULL ); } +/* +* On 64-bit, if an uncaught #GP occurs while dereferencing a non-canonical +* address, return that address. Stale comment now that it's decoding canonical addresses too.
Right, reworded.
Quoted 5 lines
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 519
Quoted 3 lines
arch/x86/kernel/traps.c +3
-0+*/ +static bool get_kernel_gp_address (struct pt_regs *regs,unsigned long *addr, +bool *non_canonical)Alignment of
non_canonicalis funky.
Fixed the indentation.
Quoted 8 lines
Quoted 8 lines
arch/x86/kernel/traps.c +8
-0+{ +#ifdef CONFIG_X86_64 +u8 insn_buf[MAX_INSN_SIZE ]; +struct insn insn; + +if (probe_kernel_read (insn_buf, (void *)regs->ip,MAX_INSN_SIZE )) +return false; +
Quoted 8 lines
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 533
Quoted 6 lines
arch/x86/kernel/traps.c +6
-0+kernel_insn_init (&insn, insn_buf,MAX_INSN_SIZE ); +insn_get_modrm (&insn); +insn_get_sib (&insn); + *addr = (unsigned long )insn_get_addr_ref (&insn, regs); + +if (*addr == (unsigned long )-1L )Nit, wouldn't -1UL avoid the need to cast?
Ooh. I incorrectly assumed that a minus sign would be part of the number literal and wouldn't be allowed for unsigned types, and didn't realize that -1UL is just -(1UL)... thanks, will adjust.
Quoted 11 lines
arch/x86/kernel/traps.c dotraplinkage void do_bounds(struct pt_regs *regs, long error_code) · line 541
Quoted 8 lines
arch/x86/kernel/traps.c +8
-0+return false; + +/* +* Check that: +* - the address is not in the kernel half or -1 (which means the +* decoder failed to decode it) +* - the last byte of the address is not in the user canonical half +*/ This -1 part of the comment should be moved above, or probably dropped entirely.
Yeah... I remember changing that as well as the comment above, I think I lost the overview and accidentally went back to an earlier version of the commit at some point... adjusted, thanks.
Quoted 3 lines
Quoted 3 lines
arch/x86/kernel/traps.c +3
-0+ *non_canonical = *addr < ~__VIRTUAL_MASK && + *addr + insn.opnd_bytes -1 > __VIRTUAL_MASK; +
[...]
Quoted 12 lines
arch/x86/kernel/traps.c do_general_protection(struct pt_regs *regs, long error_code) · line 607
Quoted 4 lines
arch/x86/kernel/traps.c +4
-0+if (addr_resolved) +snprintf (desc,sizeof (desc), +GPFSTR " probably for %saddress 0x%lx" , + non_canonical ?"non-canonical " :"" , gp_addr);I still think not explicitly calling out the straddle case will be confusing, e.g.
general protection fault probably for non-canonical address 0x7fffffffffff: 0000 [#1] SMPversus
Quoted 7 lines
general protection fault, non-canonical access 0x7fffffffffff - 0x800000000006: 0000 [#1] SMPAnd for the canonical case, "probably for address" may not be all that accurate, e.g. #GP(0) due to a instruction specific requirement is arguably just as likely to apply to the instruction itself as it is to its memory operand.
Okay, I'll bump up the level of hedging for canonical addresses to "maybe".
Quoted 5 lines
Rather than pass around multiple booleans, what about adding an enum and handling everything in (a renamed)
get_kernel_gp_address? This works especially well if address decoding is done for 32-bit as well as 64-bit, which is probably worth doing since we're printing the address in 64-bit even if it's canonical. The ifdeffery is really ugly if its 64-bit only...
The part about 32-bit makes sense to me; I've limited the CONFIG_X86_64 ifdeffery to the computation of *non_canonical.
Quoted 7 lines
enum kernel_gp_hint {
GP_NO_HINT,
GP_SEGMENT,
GP_NON_CANONICAL,
GP_STRADDLE_CANONICAL,
GP_RESOLVED_ADDR,
};I don't really like plumbing the error code down to the helper just so that it can return an enum value to us based on that; but I guess the rest of it does make the code a bit more pretty, will adjust.
Quoted 9 lines
I get that adding a print just for the straddle case is probably overkill, but it seems silly to add all this and not make it as precise as possible.
general protection fault, non-canonical address 0xdead000000000000: 0000 [#1] SMP general protection fault, non-canonical access 0x7fffffffffff - 0x800000000006: 0000 [#1] SMP general protection fault, possibly for address 0xffffc9000021bd90: 0000 [#1] SMP general protection fault, possibly for address 0xebcbde5c: 0000 [#1] SMP // 32-bit kernel
Quoted 3 lines
Side topic,
opnd_bytesisn't correct for instructions with fixed 64-bit operands (Mq notation in the opcode map), which is probably an argument against the fancy straddle logic...
And there also is nothing in the instruction decoder that could ever set opnd_bytes to 1, AFAICS. So while I think that the inaccuracies there don't really matter for the coarse "is it noncanonical #GP?" distinction right now - especially considering that userland isn't allowed to allocate the last canonical virtual page on X86-64 -, it definitely isn't accurate enough to explicitly print the access size or end address.
PATCH v4 3/4 x86/dumpstack: Split out header line printing from __die()
In reply to Jann HornSplit __die() into __die_header() and __die_body(). This allows callers to insert extra information below the header line that initiates the bug report.
This can e.g. be used by __die() callers to allow KASAN to print additional information below the header line of the bug report.
---
Notes:
I think that it's nicer to have KASAN's notes about the bug below the first oops line from the kernel. This also means that tools that work with kernel oops reports can just trigger on the "general protection fault" line with the die counter and so on, and just include the text from on there, and the KASAN message will automatically be included.
But if you think that the code looks too ugly, I'd be happy to change that back and drop this patch from the series.
v3:
new patch
v4:
no changes
arch/x86/include/asm/kdebug.h | 3 +++ arch/x86/kernel/dumpstack.c | 13 ++++++++++++- 2 files changed, 15 insertions(+), 1 deletion(-)
arch/x86/include/asm/kdebug.h +3 -0
@@ -33,6 +33,9 @@ enum show_regs_mode { };extern void die (const char *,struct pt_regs *,long ); +extern void __die_header (const char *str,struct pt_regs *regs,long err); +extern int __must_check __die_body (const char *str,struct pt_regs *regs, +long err);extern int __must_check __die (const char *,struct pt_regs *,long );extern void show_stack_regs (struct pt_regs *regs);extern void __show_regs (struct pt_regs *regs,enum show_regs_mode );
arch/x86/kernel/dumpstack.c +12 -1
@@ -365,7 +365,7 @@ void oops_end(unsigned long flags, struct pt_regs *regs, int signr) }NOKPROBE_SYMBOL (oops_end); -int __die (const char *str,struct pt_regs *regs,long err) +void __die_header (const char *str,struct pt_regs *regs,long err) {const char *pr ="" ;
@@ -384,7 +384,11 @@ int __die(const char *str, struct pt_regs *regs, long err)IS_ENABLED (CONFIG_KASAN ) ?" KASAN" :"" ,IS_ENABLED (CONFIG_PAGE_TABLE_ISOLATION ) ? (boot_cpu_has(X86_FEATURE_PTI) ? " PTI" : " NOPTI") : ""); +} +NOKPROBE_SYMBOL (__die_header); +int __die_body (const char *str,struct pt_regs *regs,long err) +{show_regs (regs);print_modules ();
@@ -394,6 +398,13 @@ int __die(const char *str, struct pt_regs *regs, long err)return 0 ; } +NOKPROBE_SYMBOL (__die_body); + +int __die (const char *str,struct pt_regs *regs,long err) +{ +__die_header (str, regs, err); +return __die_body (str, regs, err); +}NOKPROBE_SYMBOL (__die);/*
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog
PATCH v4 4/4 x86/kasan: Print original address on #GP
In reply to Jann HornMake #GP exceptions caused by out-of-bounds KASAN shadow accesses easier to understand by computing the address of the original access and printing that. More details are in the comments in the patch.
This turns an error like this:
kasan: CONFIG_KASAN_INLINE enabled
kasan: GPF could be caused by NULL-ptr deref or user memory access general protection fault probably for non-canonical address
0xe017577ddf75b7dd: 0000 [#1] PREEMPT SMP KASAN PTI
into this:
general protection fault probably for non-canonical address
0xe017577ddf75b7dd: 0000 [#1] PREEMPT SMP KASAN PTI
KASAN: maybe wild-memory-access in range
[0x00badbeefbadbee8-0x00badbeefbadbeef]The hook is placed in architecture-independent code, but is currently only wired up to the X86 exception handler because I'm not sufficiently familiar with the address space layout and exception handling mechanisms on other architectures.
---
Notes:
v2:
- move to mm/kasan/report.c (Dmitry)
- change hook name to be more generic
- use TASK_SIZE instead of TASK_SIZE_MAX for compiling on non-x86
- don't open-code KASAN_SHADOW_MASK (Dmitry)
- add "KASAN: " prefix, but not "BUG: " (Andrey, Dmitry)
- use same naming scheme as get_wild_bug_type (Andrey)
- this version was "Reviewed-by: Dmitry Vyukov <[email protected]>"
v3:
- adjusted example output in commit message based on changes in preceding patch
- ensure that KASAN output happens after bust_spinlocks(1)
- moved hook in arch/x86/kernel/traps.c such that output appears after the first line of KASAN-independent error report
v4:
- adjust patch to changes in x86/traps patch
arch/x86/kernel/traps.c | 11 ++++++++++ arch/x86/mm/kasan_init_64.c | 21 ------------------- include/linux/kasan.h | 6 ++++++ mm/kasan/report.c | 40 +++++++++++++++++++++++++++++++++++++ 4 files changed, 57 insertions(+), 21 deletions(-)
arch/x86/kernel/traps.c +11 -0
@@ -37,6 +37,7 @@#include <linux/mm.h> #include <linux/smp.h> #include <linux/io.h> +#include <linux/kasan.h> #include <asm/stacktrace.h> #include <asm/processor.h> #include <asm/debugreg.h>
@@ -574,7 +575,9 @@ do_general_protection(struct pt_regs *regs, long error_code)if (!user_mode (regs)) {bool addr_resolved = false;unsigned long gp_addr; +unsigned long flags;bool non_canonical; +int sig;if (fixup_exception (regs,X86_TRAP_GP , error_code,0 ))return ;
@@ -606,6 +609,14 @@ do_general_protection(struct pt_regs *regs, long error_code)GPFSTR " probably for %saddress 0x%lx" , non_canonical ? "non-canonical " : "", gp_addr); + flags =oops_begin (); + sig =SIGSEGV ; +__die_header (desc, regs, error_code); +if (addr_resolved && non_canonical) +kasan_non_canonical_hook (gp_addr); +if (__die_body (desc, regs, error_code)) + sig =0 ; +oops_end (flags, regs, sig);die (desc, regs, error_code);return ; }
arch/x86/mm/kasan_init_64.c +0 -21
@@ -245,23 +245,6 @@ static void __init kasan_map_early_shadow(pgd_t *pgd) }while (pgd++, addr = next, addr != end); } -#ifdef CONFIG_KASAN_INLINE -static int kasan_die_handler (struct notifier_block *self, -unsigned long val, -void *data) -{ -if (val ==DIE_GPF ) { -pr_emerg ("CONFIG_KASAN_INLINE enabled\n" ); -pr_emerg ("GPF could be caused by NULL-ptr deref or user memory access\n" ); - } -return NOTIFY_OK ; -} - -static struct notifier_block kasan_die_notifier = { - .notifier_call = kasan_die_handler, -}; -#endif -void __init kasan_early_init (void ) {int i;
@@ -298,10 +281,6 @@ void __init kasan_init(void)int i;void *shadow_cpu_entry_begin, *shadow_cpu_entry_end; -#ifdef CONFIG_KASAN_INLINE -register_die_notifier (&kasan_die_notifier); -#endif -memcpy (early_top_pgt, init_top_pgt,sizeof (early_top_pgt));/*
include/linux/kasan.h +6 -0
@@ -194,4 +194,10 @@ static inline void *kasan_reset_tag(const void *addr)#endif /* CONFIG_KASAN_SW_TAGS */ +#ifdef CONFIG_KASAN_INLINE +void kasan_non_canonical_hook (unsigned long addr); +#else /* CONFIG_KASAN_INLINE */ +static inline void kasan_non_canonical_hook (unsigned long addr) { } +#endif /* CONFIG_KASAN_INLINE */ +#endif /* LINUX_KASAN_H */
mm/kasan/report.c +40 -0
@@ -512,3 +512,43 @@ void __kasan_report(unsigned long addr, size_t size, bool is_write, unsigned lonend_report (&flags); } + +#ifdef CONFIG_KASAN_INLINE +/* +* With CONFIG_KASAN_INLINE, accesses to bogus pointers (outside the high +* canonical half of the address space) cause out-of-bounds shadow memory reads +* before the actual access. For addresses in the low canonical half of the +* address space, as well as most non-canonical addresses, that out-of-bounds +* shadow memory access lands in the non-canonical part of the address space. +* Help the user figure out what the original bogus pointer was. +*/ +void kasan_non_canonical_hook (unsigned long addr) +{ +unsigned long orig_addr; +const char *bug_type; + +if (addr <KASAN_SHADOW_OFFSET ) +return ; + + orig_addr = (addr -KASAN_SHADOW_OFFSET ) <<KASAN_SHADOW_SCALE_SHIFT ; +/* +* For faults near the shadow address for NULL, we can be fairly certain +* that this is a KASAN shadow memory access. +* For faults that correspond to shadow for low canonical addresses, we +* can still be pretty sure - that shadow region is a fairly narrow +* chunk of the non-canonical address space. +* But faults that look like shadow for non-canonical addresses are a +* really large chunk of the address space. In that case, we still +* print the decoded address, but make it clear that this is not +* necessarily what's actually going on. +*/ +if (orig_addr <PAGE_SIZE ) + bug_type ="null-ptr-deref" ; +else if (orig_addr <TASK_SIZE ) + bug_type ="probably user-memory-access" ; +else + bug_type ="maybe wild-memory-access" ; +pr_alert ("KASAN: %s in range [0x%016lx-0x%016lx]\n" , bug_type, + orig_addr, orig_addr +KASAN_SHADOW_MASK ); +} +#endif
Signature · 1 line
2.24.0.432.g9d3f5f5b63-goog