Skip to contentSkip to conversation

x86/mm: determine whether the fault address is canonical

PATCH In review Changbin Du 5 participants 9 messages Oct 4, 2019 – Oct 7, 2019

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 x86/mm: determine whether the fault address is canonical

We know the answer, so don't ask the user.

---
 arch/x86/mm/extable.c     |  5 ++++-
 arch/x86/mm/mm_internal.h | 11 +++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)
arch/x86/mm/extable.c +4 -1
index 4d75bc656f97..5196e586756f 100644
@@ -8,6 +8,8 @@
 #include <asm/traps.h>
 #include <asm/kdebug.h>
 
+#include "mm_internal.h"
+
 typedef bool (*ex_handler_t)(const struct exception_table_entry *,
 			    struct pt_regs *, int, unsigned long,
 			    unsigned long);
@@ -123,7 +125,8 @@ __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup,
 				  unsigned long error_code,
 				  unsigned long fault_addr)
 {
-	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+		  is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");
 	regs->ip = ex_fixup_addr(fixup);
 	return true;
 }
arch/x86/mm/mm_internal.h +11 -0
index eeae142062ed..4c8a0fdd1c64 100644
@@ -2,6 +2,17 @@
 #ifndef __X86_MM_INTERNAL_H
 #define __X86_MM_INTERNAL_H
 
+static inline bool is_canonical_addr(u64 addr)
+{
+#ifdef CONFIG_X86_64
+	int shift = 64 - boot_cpu_data.x86_phys_bits;
+
+	return ((int64_t)addr << shift >> shift) == addr;
+#else
+	return true;
+#endif
+}
+
 void *alloc_low_pages(unsigned int num);
 static inline void *alloc_low_page(void)
 {
Signature · 1 line
2.20.1
#1 lore raw

arch/x86/mm/mm_internal.h line 8

Quoted 4 lines · Changbin Du
arch/x86/mm/mm_internal.h +4 -0
+static inline bool is_canonical_addr(u64 addr)
+{
+#ifdef CONFIG_X86_64
+	int shift = 64 - boot_cpu_data.x86_phys_bits;

I think you mean to check the virtual bits member, not "phys_bits".

BTW, I also prefer the IS_ENABLED(CONFIG_) checks to explicit #ifdefs. Would one of those work in this case?

As for the error message:

arch/x86/mm/extable.c __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup, · line 129

Quoted 4 lines

{

arch/x86/mm/extable.c +2 -1
-	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+		  is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");

I've always read that as "the GP might have been caused by a non-canonical access". The main nit I'd have with the change is that I don't think all #GP's during user access functions which are given a non-canonical address *necessarily* caused the #GP.

There are a billion ways you can get a #GP and I bet canonical violations aren't the only way you can get one in a user copy function.

maintainer
#6 lore raw
In reply to Changbin Du
Quoted 23 lines · Changbin Du

We know the answer, so don't ask the user.

---
 arch/x86/mm/extable.c     |  5 ++++-
 arch/x86/mm/mm_internal.h | 11 +++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)
arch/x86/mm/extable.c +2 -0
index 4d75bc656f97..5196e586756f 100644
@@ -8,6 +8,8 @@
 #include <asm/traps.h>
 #include <asm/kdebug.h>
 
+#include "mm_internal.h"
+
 typedef bool (*ex_handler_t)(const struct exception_table_entry *,
                            struct pt_regs *, int, unsigned long,
                            unsigned long);

arch/x86/mm/extable.c __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup, · line 129

Quoted 6 lines
arch/x86/mm/extable.c +2 -1
@@ -123,7 +125,8 @@ __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup,
                                  unsigned long error_code,
                                  unsigned long fault_addr)
 {
-       WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+       WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+                 is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");

Unless the hardware behaves rather differently from the way I think it does, fault_addr is garbage for anything other than #PF and sometimes for #DF. (And maybe the virtualization faults?) I don't believe that #GP fills in CR2.

#7 lore raw
Quoted 11 lines · Andy Lutomirski

arch/x86/mm/extable.c __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup, · line 129

Quoted 7 lines
arch/x86/mm/extable.c +2 -1
@@ -123,7 +125,8 @@ __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup,
                                  unsigned long error_code,
                                  unsigned long fault_addr)
 {
-       WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+       WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+                 is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");

Unless the hardware behaves rather differently from the way I think it does, fault_addr is garbage for anything other than #PF and sometimes for #DF. (And maybe the virtualization faults?) I don't believe that #GP fills in CR2.

For #GP, we do:

do_general_protection(struct pt_regs *regs, long error_code) {
...

        if (!user_mode(regs)) {
                if (fixup_exception(regs, X86_TRAP_GP, error_code, 0))
                        return;

Where the 0 is 'fault_addr'. I'm not sure any other way that ex_handler_uaccess() can get called with trapnr == X86_TRAP_GP. 0 is canonical last I checked, which would make this patch a bit academic. :)

#2 lore raw
In reply to Dave Hansen
Quoted 23 lines · Dave Hansen

arch/x86/mm/mm_internal.h line 8

Quoted 4 lines · Changbin Du
arch/x86/mm/mm_internal.h +4 -0
+static inline bool is_canonical_addr(u64 addr)
+{
+#ifdef CONFIG_X86_64
+	int shift = 64 - boot_cpu_data.x86_phys_bits;

I think you mean to check the virtual bits member, not "phys_bits".

BTW, I also prefer the IS_ENABLED(CONFIG_) checks to explicit #ifdefs. Would one of those work in this case?

As for the error message:

arch/x86/mm/extable.c __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup, · line 129

Quoted 4 lines

{

arch/x86/mm/extable.c +2 -1
-	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+		  is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");

I've always read that as "the GP might have been caused by a non-canonical access". The main nit I'd have with the change is that I don't think all #GP's during user access functions which are given a non-canonical address *necessarily* caused the #GP.

Quoted 2 lines

There are a billion ways you can get a #GP and I bet canonical violations aren't the only way you can get one in a user copy function.

All the other reasons would require a fairly egregious kernel bug, hence the speculation that the #GP is due to a non-canonical address. Something like the following would be more precise, though highly unlikely to ever be exercised, e.g. KVM had a fatal bug related to injecting a non-zero error code that went unnoticed for years.

	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. %s?\n",
		  (IS_ENABLED(CONFIG_X86_64) && !error_code) ? "Non-canonical address" :
		  					       "Segmentation bug");
#8 lore raw
In reply to Dave Hansen
Quoted 18 lines · Dave Hansen
Quoted 11 lines · Andy Lutomirski

arch/x86/mm/extable.c __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup, · line 129

Quoted 7 lines
arch/x86/mm/extable.c +2 -1
@@ -123,7 +125,8 @@ __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup,
                                  unsigned long error_code,
                                  unsigned long fault_addr)
 {
-       WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+       WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+                 is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");

Unless the hardware behaves rather differently from the way I think it does, fault_addr is garbage for anything other than #PF and sometimes for #DF. (And maybe the virtualization faults?) I don't believe that #GP fills in CR2.

For #GP, we do:

do_general_protection(struct pt_regs *regs, long error_code) {
...

Quoted 7 lines
        if (!user_mode(regs)) {
                if (fixup_exception(regs, X86_TRAP_GP, error_code, 0))
                        return;

Where the 0 is 'fault_addr'. I'm not sure any other way that ex_handler_uaccess() can get called with trapnr == X86_TRAP_GP. 0 is canonical last I checked, which would make this patch a bit academic. :)

My fault. I thought the 'fault_addr' is filled with a valid value. So we really don't know the answer without decoding the instruction which causes this #GP. :)

Signature · 2 lines
Cheers,
Changbin Du
#3 lore raw
In reply to Sean Christopherson
Quoted 33 lines · Sean Christopherson
Quoted 23 lines · Dave Hansen

arch/x86/mm/mm_internal.h line 8

Quoted 4 lines · Changbin Du
arch/x86/mm/mm_internal.h +4 -0
+static inline bool is_canonical_addr(u64 addr)
+{
+#ifdef CONFIG_X86_64
+	int shift = 64 - boot_cpu_data.x86_phys_bits;

I think you mean to check the virtual bits member, not "phys_bits".

BTW, I also prefer the IS_ENABLED(CONFIG_) checks to explicit #ifdefs. Would one of those work in this case?

As for the error message:

arch/x86/mm/extable.c __visible bool ex_handler_uaccess(const struct exception_table_entry *fixup, · line 129

Quoted 4 lines

{

arch/x86/mm/extable.c +2 -1
-	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. Non-canonical address?");
+	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault at %s address in user access.",
+		  is_canonical_addr(fault_addr) ? "canonical" : "non-canonical");

I've always read that as "the GP might have been caused by a non-canonical access". The main nit I'd have with the change is that I don't think all #GP's during user access functions which are given a non-canonical address *necessarily* caused the #GP.

Quoted 2 lines

There are a billion ways you can get a #GP and I bet canonical violations aren't the only way you can get one in a user copy function.

All the other reasons would require a fairly egregious kernel bug, hence the speculation that the #GP is due to a non-canonical address. Something like the following would be more precise, though highly unlikely to ever be exercised, e.g. KVM had a fatal bug related to injecting a non-zero error code that went unnoticed for years.

Quoted 3 lines
	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. %s?\n",
		  (IS_ENABLED(CONFIG_X86_64) && !error_code) ? "Non-canonical address" :
		  					       "Segmentation bug");

Instead of trying to guess the reason of the #GPF (which guess might be wrong), please just state it as the reason if we are sure that the cause is a non-canonical address - and provide a best-guess if it's not but clearly signal that it's a guess.

I.e. if I understood all the cases correctly we'd have three types of messages generated:

!error_code:
"General protection fault in user access, due to non-canonical address."

error_code && !is_canonical_addr(fault_addr):
"General protection fault in user access. Non-canonical address?"

error_code && is_canonical_addr(fault_addr):
"General protection fault in user access. Segmentation bug?"

Only the first one is declarative, because we know we got a #GP with a zero error code which should denote a non-canonical address access.

The second and third ones are guesses with question marks to communicate the uncertainty.

Assuming that !error_code always means non-canonical access?

And hopefully "!error_code && !is_canonical_addr(fault_addr)" is not possible?

Thanks,

Ingo

#4 lore raw
Quoted 18 lines · Ingo Molnar
Quoted 9 lines

All the other reasons would require a fairly egregious kernel bug, hence the speculation that the #GP is due to a non-canonical address. Something like the following would be more precise, though highly unlikely to ever be exercised, e.g. KVM had a fatal bug related to injecting a non-zero error code that went unnoticed for years.

	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. %s?\n",
		  (IS_ENABLED(CONFIG_X86_64) && !error_code) ? "Non-canonical address" :
		  					       "Segmentation bug");

Instead of trying to guess the reason of the #GPF (which guess might be wrong), please just state it as the reason if we are sure that the cause is a non-canonical address - and provide a best-guess if it's not but clearly signal that it's a guess.

I.e. if I understood all the cases correctly we'd have three types of messages generated:

Quoted 8 lines

!error_code:
"General protection fault in user access, due to non-canonical address."

error_code && !is_canonical_addr(fault_addr):
"General protection fault in user access. Non-canonical address?"

error_code && is_canonical_addr(fault_addr):
"General protection fault in user access. Segmentation bug?"

Now that I've read the rest of the thread, since fault_addr is always 0 we can ignore most of this I suspect ...

Thanks,

Ingo

#5 lore raw
Quoted 18 lines · Ingo Molnar
Quoted 15 lines · Ingo Molnar
Quoted 9 lines

All the other reasons would require a fairly egregious kernel bug, hence the speculation that the #GP is due to a non-canonical address. Something like the following would be more precise, though highly unlikely to ever be exercised, e.g. KVM had a fatal bug related to injecting a non-zero error code that went unnoticed for years.

	WARN_ONCE(trapnr == X86_TRAP_GP, "General protection fault in user access. %s?\n",
		  (IS_ENABLED(CONFIG_X86_64) && !error_code) ? "Non-canonical address" :
		  					       "Segmentation bug");

Instead of trying to guess the reason of the #GPF (which guess might be wrong), please just state it as the reason if we are sure that the cause is a non-canonical address - and provide a best-guess if it's not but clearly signal that it's a guess.

Quoted 5 lines
Quoted 5 lines

I.e. if I understood all the cases correctly we'd have three types of messages generated:

!error_code:
"General protection fault in user access, due to non-canonical address."

A non-canonical #GP always has an error code of '0', but the reverse isn't technically true. And 32-bit mode obviously can't generate a non-canonical address.

But practically speaking, since _ASM_EXTABLE_UA() should only be used for reg<->mem instructions, the only way to get a #GP on a usercopy instruction would be to corrupt the code itself or have a bad segment loaded in 32-bit mode. So qualifying the non-canonical message on '64-bit && !error_code' is techncally more precise/correct, but likely meaningless in practice.

Quoted 8 lines
Quoted 5 lines

error_code && !is_canonical_addr(fault_addr):
"General protection fault in user access. Non-canonical address?"

error_code && is_canonical_addr(fault_addr):
"General protection fault in user access. Segmentation bug?"

Now that I've read the rest of the thread, since fault_addr is always 0 we can ignore most of this I suspect ...