livepatch: hybrid consistency model

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +0 -0

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,

Quoted 33 lines · Josh Poimboeuf

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +0 -2

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
         *              address given in m16:64.
         */
-       movq    initial_code(%rip),%rax
-       pushq   $0              # fake return address to stop unwinder

arch/x86/kernel/head_64.S ENTRY(start_cpu) · line 304

Quoted 6 lines

arch/x86/kernel/head_64.S +3 -0

+       call    1f              # put return address on stack for unwinder
+1:     xorq    %rbp, %rbp      # clear frame pointer
+       movq    initial_code(%rip), %rax
        pushq   $__KERNEL_CS    # set correct cs
        pushq   %rax            # target address in negative space
        lretq

This chunk looks like it should be a separate patch.

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +3 -2

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
         *              address given in m16:64.
         */
-       movq    initial_code(%rip),%rax
-       pushq   $0              # fake return address to stop unwinder
+       call    1f              # put return address on stack for unwinder
+1:     xorq    %rbp, %rbp      # clear frame pointer
+       movq    initial_code(%rip), %rax
        pushq   $__KERNEL_CS    # set correct cs
        pushq   %rax            # target address in negative space
        lretq

Quoted 41 lines · Josh Poimboeuf

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +3 -2

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
         *              address given in m16:64.
         */
-       movq    initial_code(%rip),%rax
-       pushq   $0              # fake return address to stop unwinder
+       call    1f              # put return address on stack for unwinder
+1:     xorq    %rbp, %rbp      # clear frame pointer
+       movq    initial_code(%rip), %rax
        pushq   $__KERNEL_CS    # set correct cs
        pushq   %rax            # target address in negative space
        lretq

@@ -325,7 +326,7 @@ ENDPROC(start_cpu0)
        GLOBAL(initial_gs)

arch/x86/kernel/head_64.S ENDPROC(start_cpu0) · line 329

Quoted 4 lines

arch/x86/kernel/head_64.S +1 -1

        .quad   INIT_PER_CPU_VAR(irq_stack_union)
        GLOBAL(initial_stack)
-       .quad  init_thread_union+THREAD_SIZE-8
+       .quad  init_thread_union + THREAD_SIZE - SIZEOF_PTREGS

As long as you're doing this, could you also set orig_ax to -1? I remember running into some oddities resulting from orig_ax containing garbage at some point.

Quoted 42 lines · Andy Lutomirski

Quoted 41 lines · Josh Poimboeuf

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +3 -2

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
         *              address given in m16:64.
         */
-       movq    initial_code(%rip),%rax
-       pushq   $0              # fake return address to stop unwinder
+       call    1f              # put return address on stack for unwinder
+1:     xorq    %rbp, %rbp      # clear frame pointer
+       movq    initial_code(%rip), %rax
        pushq   $__KERNEL_CS    # set correct cs
        pushq   %rax            # target address in negative space
        lretq

@@ -325,7 +326,7 @@ ENDPROC(start_cpu0)
        GLOBAL(initial_gs)

Quoted 8 lines

arch/x86/kernel/head_64.S ENDPROC(start_cpu0) · line 329

Quoted 4 lines

arch/x86/kernel/head_64.S +1 -1

        .quad   INIT_PER_CPU_VAR(irq_stack_union)
        GLOBAL(initial_stack)
-       .quad  init_thread_union+THREAD_SIZE-8
+       .quad  init_thread_union + THREAD_SIZE - SIZEOF_PTREGS

As long as you're doing this, could you also set orig_ax to -1? I remember running into some oddities resulting from orig_ax containing garbage at some point.

I assume you mean to initialize the orig_rax value in the pt_regs at the bottom of the stack of the idle task?

How could that cause a problem? Since the idle task never returns from a system call, I'd assume that memory never gets accessed?

--
Josh

Quoted 52 lines · Josh Poimboeuf

Quoted 50 lines · Andy Lutomirski

Quoted 40 lines · Josh Poimboeuf

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +3 -2

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
         *              address given in m16:64.
         */
-       movq    initial_code(%rip),%rax
-       pushq   $0              # fake return address to stop unwinder
+       call    1f              # put return address on stack for unwinder
+1:     xorq    %rbp, %rbp      # clear frame pointer
+       movq    initial_code(%rip), %rax
        pushq   $__KERNEL_CS    # set correct cs
        pushq   %rax            # target address in negative space
        lretq

arch/x86/kernel/head_64.S ENDPROC(start_cpu0) · line 329

Quoted 5 lines

arch/x86/kernel/head_64.S +1 -1

@@ -325,7 +326,7 @@ ENDPROC(start_cpu0)
        GLOBAL(initial_gs)
        .quad   INIT_PER_CPU_VAR(irq_stack_union)
        GLOBAL(initial_stack)
-       .quad  init_thread_union+THREAD_SIZE-8
+       .quad  init_thread_union + THREAD_SIZE - SIZEOF_PTREGS

As long as you're doing this, could you also set orig_ax to -1? I remember running into some oddities resulting from orig_ax containing garbage at some point.

Quoted 6 lines

I assume you mean to initialize the orig_rax value in the pt_regs at the bottom of the stack of the idle task?

How could that cause a problem? Since the idle task never returns from a system call, I'd assume that memory never gets accessed?

Look at collect_syscall in lib/syscall.c

Quoted 60 lines · Andy Lutomirski

Quoted 58 lines · Josh Poimboeuf

Quoted 42 lines · Andy Lutomirski

Quoted 41 lines · Josh Poimboeuf

Thanks to all the recent x86 entry code refactoring, most tasks' kernel stacks start at the same offset right above their saved pt_regs, regardless of which syscall was used to enter the kernel. That creates a nice convention which makes it straightforward to identify the "bottom" of the stack, which can be useful for stack walking code which needs to verify the stack is sane.

However there are still a few types of tasks which don't yet follow that convention:

1) CPU idle tasks, aka the "swapper" tasks

2) freshly forked TIF_FORK tasks which don't have a stack at all

Make the idle tasks conform to the new stack bottom convention by starting their stack at a sizeof(pt_regs) offset from the end of the stack page.

Signed-off-by Josh Poimboeuf <[email protected]>

---
 arch/x86/kernel/head_64.S | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

arch/x86/kernel/head_64.S +3 -2

index 6dbd2c0..0b12311 100644
@@ -296,8 +296,9 @@ ENTRY(start_cpu)
         *      REX.W + FF /5 JMP m16:64 Jump far, absolute indirect,
         *              address given in m16:64.
         */
-       movq    initial_code(%rip),%rax
-       pushq   $0              # fake return address to stop unwinder
+       call    1f              # put return address on stack for unwinder
+1:     xorq    %rbp, %rbp      # clear frame pointer
+       movq    initial_code(%rip), %rax
        pushq   $__KERNEL_CS    # set correct cs
        pushq   %rax            # target address in negative space
        lretq

@@ -325,7 +326,7 @@ ENDPROC(start_cpu0)
        GLOBAL(initial_gs)

Quoted 8 lines

arch/x86/kernel/head_64.S ENDPROC(start_cpu0) · line 329

Quoted 4 lines

arch/x86/kernel/head_64.S +1 -1

        .quad   INIT_PER_CPU_VAR(irq_stack_union)
        GLOBAL(initial_stack)
-       .quad  init_thread_union+THREAD_SIZE-8
+       .quad  init_thread_union + THREAD_SIZE - SIZEOF_PTREGS

As long as you're doing this, could you also set orig_ax to -1? I remember running into some oddities resulting from orig_ax containing garbage at some point.

I assume you mean to initialize the orig_rax value in the pt_regs at the bottom of the stack of the idle task?

How could that cause a problem? Since the idle task never returns from a system call, I'd assume that memory never gets accessed?

Quoted 1 line

Look at collect_syscall in lib/syscall.c

I don't see how collect_syscall() can be called for the per-cpu idle "swapper" tasks (which is what the above code affects). They don't have pids or /proc entries so you can't do /proc/<pid>/syscall on them.

--
Josh

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

Quoted 6 lines · Josh Poimboeuf

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

I think I like this, but how do you handle the rather similar case in which a task goes to sleep because it's waiting on IO that happened in response to get_user, put_user, copy_from_user, etc?

Quoted 11 lines · Andy Lutomirski

Quoted 6 lines · Josh Poimboeuf

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

I think I like this, but how do you handle the rather similar case in which a task goes to sleep because it's waiting on IO that happened in response to get_user, put_user, copy_from_user, etc?

Hm, good question. I was thinking that page faults had a dedicated stack, but now looking at the entry and traps code, that doesn't seem to be the case.

Anyway I think it shouldn't be a problem if we make sure that any kernel function which might trigger a valid page fault (e.g., copy_user_generic_string) do the proper frame pointer setup first. Then the stack should still be reliable.

In fact I might be able to teach objtool to enforce that: any function which uses an exception table should create a stack frame.

Or alternatively, maybe set some kind of flag for page faults, similar to what I did with this patch.

Quoted 22 lines · Josh Poimboeuf

Quoted 11 lines · Andy Lutomirski

Quoted 6 lines · Josh Poimboeuf

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

I think I like this, but how do you handle the rather similar case in which a task goes to sleep because it's waiting on IO that happened in response to get_user, put_user, copy_from_user, etc?

Hm, good question. I was thinking that page faults had a dedicated stack, but now looking at the entry and traps code, that doesn't seem to be the case.

Anyway I think it shouldn't be a problem if we make sure that any kernel function which might trigger a valid page fault (e.g., copy_user_generic_string) do the proper frame pointer setup first. Then the stack should still be reliable.

Quoted 6 lines

In fact I might be able to teach objtool to enforce that: any function which uses an exception table should create a stack frame.

Or alternatively, maybe set some kind of flag for page faults, similar to what I did with this patch.

How about doing it the other way around: teach the unwinder to detect when it hits a non-outermost entry (i.e. it lands in idtentry, etc) and use some reasonable heuristic as to whether it's okay to keep unwinding. You should be able to handle preemption like that, too -- the unwind process will end up in an IRQ frame.

Quoted 30 lines · Andy Lutomirski

Quoted 28 lines · Josh Poimboeuf

Quoted 11 lines · Andy Lutomirski

Quoted 6 lines · Josh Poimboeuf

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

I think I like this, but how do you handle the rather similar case in which a task goes to sleep because it's waiting on IO that happened in response to get_user, put_user, copy_from_user, etc?

Hm, good question. I was thinking that page faults had a dedicated stack, but now looking at the entry and traps code, that doesn't seem to be the case.

Anyway I think it shouldn't be a problem if we make sure that any kernel function which might trigger a valid page fault (e.g., copy_user_generic_string) do the proper frame pointer setup first. Then the stack should still be reliable.

In fact I might be able to teach objtool to enforce that: any function which uses an exception table should create a stack frame.

Or alternatively, maybe set some kind of flag for page faults, similar to what I did with this patch.

Quoted 5 lines

How about doing it the other way around: teach the unwinder to detect when it hits a non-outermost entry (i.e. it lands in idtentry, etc) and use some reasonable heuristic as to whether it's okay to keep unwinding. You should be able to handle preemption like that, too -- the unwind process will end up in an IRQ frame.

How exactly would the unwinder detect if a text address is in an idtentry? Maybe put all the idt entries in a special ELF section?

Quoted 31 lines · Josh Poimboeuf

Quoted 30 lines · Andy Lutomirski

Quoted 28 lines · Josh Poimboeuf

Quoted 11 lines · Andy Lutomirski

Quoted 6 lines · Josh Poimboeuf

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

I think I like this, but how do you handle the rather similar case in which a task goes to sleep because it's waiting on IO that happened in response to get_user, put_user, copy_from_user, etc?

Hm, good question. I was thinking that page faults had a dedicated stack, but now looking at the entry and traps code, that doesn't seem to be the case.

Anyway I think it shouldn't be a problem if we make sure that any kernel function which might trigger a valid page fault (e.g., copy_user_generic_string) do the proper frame pointer setup first. Then the stack should still be reliable.

In fact I might be able to teach objtool to enforce that: any function which uses an exception table should create a stack frame.

Or alternatively, maybe set some kind of flag for page faults, similar to what I did with this patch.

Quoted 9 lines

Quoted 5 lines

How about doing it the other way around: teach the unwinder to detect when it hits a non-outermost entry (i.e. it lands in idtentry, etc) and use some reasonable heuristic as to whether it's okay to keep unwinding. You should be able to handle preemption like that, too -- the unwind process will end up in an IRQ frame.

How exactly would the unwinder detect if a text address is in an idtentry? Maybe put all the idt entries in a special ELF section?

Hmm.

What actually happens when you unwind all the way into the entry code?
Don't you end up in something that isn't in an ELF function? Can you
detect that?

Ideally, the unwinder could actually detect that it's
hit a pt_regs struct and report that. If used for stack dumps, it could display some indication of this and then continue its unwinding by decoding the pt_regs. If used for patching, it could take some other appropriate action.

I would have no objection to annotating all the pt_regs-style entry code, whether by putting it in a separate section or by making a table of addresses.

There are a couple of nasty cases if NMI or MCE is involved but, as of 4.6, outside of NMI, MCE, and vmalloc faults (ugh!), there should always be a complete pt_regs on the stack before interrupts get enabled for each entry. Of course, finding the thing may be nontrivial in case other things were pushed.

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

Quoted 42 lines · Andy Lutomirski

Quoted 31 lines · Josh Poimboeuf

Quoted 30 lines · Andy Lutomirski

Quoted 28 lines · Josh Poimboeuf

Quoted 11 lines · Andy Lutomirski

Quoted 6 lines · Josh Poimboeuf

A preempted function might not have had a chance to save the frame pointer to the stack yet, which can result in its caller getting skipped on a stack trace.

Add a flag to indicate when the task has been preempted so that stack dump code can determine whether the stack trace is reliable.

I think I like this, but how do you handle the rather similar case in which a task goes to sleep because it's waiting on IO that happened in response to get_user, put_user, copy_from_user, etc?

Hm, good question. I was thinking that page faults had a dedicated stack, but now looking at the entry and traps code, that doesn't seem to be the case.

Anyway I think it shouldn't be a problem if we make sure that any kernel function which might trigger a valid page fault (e.g., copy_user_generic_string) do the proper frame pointer setup first. Then the stack should still be reliable.

In fact I might be able to teach objtool to enforce that: any function which uses an exception table should create a stack frame.

Or alternatively, maybe set some kind of flag for page faults, similar to what I did with this patch.

Quoted 9 lines

Quoted 5 lines

How about doing it the other way around: teach the unwinder to detect when it hits a non-outermost entry (i.e. it lands in idtentry, etc) and use some reasonable heuristic as to whether it's okay to keep unwinding. You should be able to handle preemption like that, too -- the unwind process will end up in an IRQ frame.

How exactly would the unwinder detect if a text address is in an idtentry? Maybe put all the idt entries in a special ELF section?

Quoted 5 lines

Hmm.

What actually happens when you unwind all the way into the entry code?
Don't you end up in something that isn't in an ELF function? Can you
detect that?

For entry from user space (e.g., syscalls), it's easy to detect because there's always a pt_regs at the bottom of the stack. So if the unwinder reaches the stack address at (thread.sp0 - sizeof(pt_regs)), it knows it's done.

But for nested entry (e.g. in-kernel irqs/exceptions like preemption and page faults which don't have dedicated stacks), where the pt_regs is stored somewhere in the middle of the stack instead of the bottom, there's no reliable way to detect that.

Quoted 6 lines

Ideally, the unwinder could actually detect that it's
hit a pt_regs struct and report that. If used for stack dumps, it could display some indication of this and then continue its unwinding by decoding the pt_regs. If used for patching, it could take some other appropriate action.

Quoted 3 lines

I would have no objection to annotating all the pt_regs-style entry code, whether by putting it in a separate section or by making a table of addresses.

I think the easiest way to make it work would be to modify the idtentry macro to put all the idt entries in a dedicated section. Then the unwinder could easily detect any calls from that code.

Quoted 6 lines

There are a couple of nasty cases if NMI or MCE is involved but, as of 4.6, outside of NMI, MCE, and vmalloc faults (ugh!), there should always be a complete pt_regs on the stack before interrupts get enabled for each entry. Of course, finding the thing may be nontrivial in case other things were pushed.

NMI, MCE and interrupts aren't a problem because they have dedicated stacks, which are easy to detect. If the tasks' stack is on an exception stack or an irq stack, we consider it unreliable.

And also, they don't sleep. The stack of any running task (other than current) is automatically considered unreliable anyway, since they could be modifying it while we're reading it.

Quoted 3 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

Quoted 3 lines

NMI, MCE and interrupts aren't a problem because they have dedicated stacks, which are easy to detect. If the tasks' stack is on an exception stack or an irq stack, we consider it unreliable.

Only on x86_64.

Quoted 4 lines · Andy Lutomirski

Quoted 3 lines

NMI, MCE and interrupts aren't a problem because they have dedicated stacks, which are easy to detect. If the tasks' stack is on an exception stack or an irq stack, we consider it unreliable.

Quoted 1 line

Only on x86_64.

Well, MCEs are more or less x86-specific as well. But otherwise good point, thanks Andy.

So, how does stack layout generally look like in case when NMI is actually running on proper kernel stack? I thought it's guaranteed to contain pt_regs anyway in all cases. Is that not guaranteed to be the case?

Quoted 4 lines · Andy Lutomirski

Quoted 3 lines

NMI, MCE and interrupts aren't a problem because they have dedicated stacks, which are easy to detect. If the tasks' stack is on an exception stack or an irq stack, we consider it unreliable.

Quoted 1 line

Only on x86_64.

Well, MCEs are more or less x86-specific as well. But otherwise good point, thanks Andy.

So, how does stack layout generally look like in case when NMI is actually running on proper kernel stack? I thought it's guaranteed to contain pt_regs anyway in all cases. Is that not guaranteed to be the case?

Quoted 3 lines · Josh Poimboeuf

I think the easiest way to make it work would be to modify the idtentry macro to put all the idt entries in a dedicated section. Then the unwinder could easily detect any calls from that code.

That would work. Would it make sense to do the same for the irq entries?

Quoted 5 lines

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

We should really re-add DWARF some day.

Quoted 6 lines · Andy Lutomirski

Quoted 3 lines · Josh Poimboeuf

I think the easiest way to make it work would be to modify the idtentry macro to put all the idt entries in a dedicated section. Then the unwinder could easily detect any calls from that code.

That would work. Would it make sense to do the same for the irq entries?

Yes, I think so.

Quoted 8 lines

Quoted 5 lines

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Quoted 2 lines

We should really re-add DWARF some day.

Working on it :-)

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Have you looked at my vdso unwinding test at all? If we could do something similar for the kernel, IMO it would make testing much more pleasant.

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Quoted 4 lines

Have you looked at my vdso unwinding test at all? If we could do something similar for the kernel, IMO it would make testing much more pleasant.

I found it, but I'm not sure what it would mean to do something similar for the kernel. Do you mean doing something like an NMI sampling-based approach where we periodically do a random stack sanity check?

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion.

But this is pretty simple and performance is already abysmal in most handlers.

There's an added benefit to using a separate section, though: we could also annotate the calls with what type of entry they were so the unwinder could print it out nicely.

Quoted 7 lines

Quoted 3 lines

Have you looked at my vdso unwinding test at all? If we could do something similar for the kernel, IMO it would make testing much more pleasant.

I found it, but I'm not sure what it would mean to do something similar for the kernel. Do you mean doing something like an NMI sampling-based approach where we periodically do a random stack sanity check?

I was imagining something a little more strict: single-step interesting parts of the kernel and make sure that each step unwinds correctly. That could detect missing frames and similar.

Quoted 69 lines · Andy Lutomirski

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

Quoted 6 lines

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

Yeah, that's about what I had in mind.

Quoted 4 lines

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion.

Hm, this I don't really follow. It's true that the unwinder can easily find RIP from pt_regs, which will always be a known offset from the kernel_entry pointer on the stack. But why would having the entry code in a separate section make that faster?

Quoted 7 lines

But this is pretty simple and performance is already abysmal in most handlers.

There's an added benefit to using a separate section, though: we could also annotate the calls with what type of entry they were so the unwinder could print it out nicely.

Yeah, that could be a nice feature... but doesn't printing the name of the C handler pretty much already give that information?

In any case, once we have a working DWARF unwinder, I think it will show the name of the idt entry anyway.

Quoted 5 lines

Quoted 5 lines

Quoted 4 lines

Have you looked at my vdso unwinding test at all? If we could do something similar for the kernel, IMO it would make testing much more pleasant.

Quoted 7 lines

Quoted 3 lines

I found it, but I'm not sure what it would mean to do something similar for the kernel. Do you mean doing something like an NMI sampling-based approach where we periodically do a random stack sanity check?

I was imagining something a little more strict: single-step interesting parts of the kernel and make sure that each step unwinds correctly. That could detect missing frames and similar.

Interesting idea, though I wonder how hard it would be to reliably distinguish a missing frame from the case where gcc decides to inline a function.

Another idea to detect missing frames: for each return address on the stack, ensure there's a corresponding "call <func>" instruction immediately preceding the return location, where <func> matches what's on the stack.

Quoted 3 lines

Another idea to detect missing frames: for each return address on the stack, ensure there's a corresponding "call <func>" instruction immediately preceding the return location, where <func> matches what's on the stack.

Hmm, interesting.

I hope your plans include rewriting the current stack unwinder completely. The thing in print_context_stack is (a) hard-to-understand and hard-to-modify crap and (b) is called in a loop from another file using totally ridiculous conventions.

Quoted 70 lines · Josh Poimboeuf

Quoted 69 lines · Andy Lutomirski

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

Quoted 8 lines

Quoted 6 lines

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

Yeah, that's about what I had in mind.

FWIW, I just tried this:

static bool is_entry_text(unsigned long addr)

{
    return addr >= (unsigned long)__entry_text_start &&
        addr < (unsigned long)__entry_text_end;
}

it works. So the entry code is already annotated reasonably well :)

I just hacked it up here:

https://git.kernel.org/cgit/linux/kernel/git/luto/linux.git/commit/?h=stack&id=085eacfe0edfc18768e48340084415dba9a6bd21

and it seems to work, at least for page faults. A better implementation would print out the entire contents of pt_regs so that people reading the stack trace will know the registers at the time of the exception, which might be helpful.

Quoted 8 lines

Quoted 3 lines

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion.

Hm, this I don't really follow. It's true that the unwinder can easily find RIP from pt_regs, which will always be a known offset from the kernel_entry pointer on the stack. But why would having the entry code in a separate section make that faster?

It doesn't make the unwinder faster -- it makes the entry code faster.

I hope your plans include rewriting the current stack unwinder completely. The thing in print_context_stack is (a) hard-to-understand and hard-to-modify crap and (b) is called in a loop from another file using totally ridiculous conventions.

FWIW, I just tried this:

static bool is_entry_text(unsigned long addr)

{
    return addr >= (unsigned long)__entry_text_start &&
        addr < (unsigned long)__entry_text_end;
}

it works. So the entry code is already annotated reasonably well :)

I just hacked it up here:

https://git.kernel.org/cgit/linux/kernel/git/luto/linux.git/commit/?h=stack&id=085eacfe0edfc18768e48340084415dba9a6bd21

and it seems to work, at least for page faults. A better implementation would print out the entire contents of pt_regs so that people reading the stack trace will know the registers at the time of the exception, which might be helpful.

Quoted 14 lines

FWIW, I just tried this:

static bool is_entry_text(unsigned long addr)

{
    return addr >= (unsigned long)__entry_text_start &&
        addr < (unsigned long)__entry_text_end;
}

it works. So the entry code is already annotated reasonably well :)

I just hacked it up here:

https://git.kernel.org/cgit/linux/kernel/git/luto/linux.git/commit/?h=stack&id=085eacfe0edfc18768e48340084415dba9a6bd21

Quoted 4 lines

and it seems to work, at least for page faults. A better implementation would print out the entire contents of pt_regs so that people reading the stack trace will know the registers at the time of the exception, which might be helpful.

Sorry for being dense, but how do you distinguish here between a "real" kernel entry, that pushes pt_regs, and any "non-entry" function call that passes pt_regs around?

Quoted 19 lines · Jiri Kosina

Quoted 18 lines

FWIW, I just tried this:

static bool is_entry_text(unsigned long addr)

{
    return addr >= (unsigned long)__entry_text_start &&
        addr < (unsigned long)__entry_text_end;
}

it works. So the entry code is already annotated reasonably well :)

I just hacked it up here:

https://git.kernel.org/cgit/linux/kernel/git/luto/linux.git/commit/?h=stack&id=085eacfe0edfc18768e48340084415dba9a6bd21

and it seems to work, at least for page faults. A better implementation would print out the entire contents of pt_regs so that people reading the stack trace will know the registers at the time of the exception, which might be helpful.

Quoted 3 lines

Sorry for being dense, but how do you distinguish here between a "real" kernel entry, that pushes pt_regs, and any "non-entry" function call that passes pt_regs around?

Umm, actually, the more tricky part is the other way around -- how do you make sure that whenever you are calling out from a code between __entry_text_start and __entry_text_end, pt_regs will be at the place you're looking for it? How's that guaranteed?

Thanks,

--
Jiri Kosina
SUSE Labs

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion. But this is pretty simple and performance is already abysmal in most handlers.

There's an added benefit to using a separate section, though: we could also annotate the calls with what type of entry they were so the unwinder could print it out nicely.

I could be convinced either way.

Quoted 82 lines · Andy Lutomirski

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion. But this is pretty simple and performance is already abysmal in most handlers.

Quoted 5 lines

There's an added benefit to using a separate section, though: we could also annotate the calls with what type of entry they were so the unwinder could print it out nicely.

I could be convinced either way.

Ok, I took a stab at this. See the patch below.

In addition to annotating interrupt/exception pt_regs frames, I also annotated all the syscall pt_regs, for consistency.

As you mentioned, it will affect performance a bit, but I think it will be insignificant.

I think I like this approach better than putting the interrupt/idtentry's in a special section, because this is much more precise. Especially now that I'm annotating pt_regs syscalls.

Also I think with a few minor changes we could implement your idea of annotating the calls with what type of entry they are. But I don't think that's really needed, because the name of the interrupt/idtentry is already on the stack trace.

Before:

  [<ffffffff8143c243>] dump_stack+0x85/0xc2
  [<ffffffff81073596>] __do_page_fault+0x576/0x5a0
  [<ffffffff8107369c>] trace_do_page_fault+0x5c/0x2e0
  [<ffffffff8106d83c>] do_async_page_fault+0x2c/0xa0
  [<ffffffff81887058>] async_page_fault+0x28/0x30
  [<ffffffff81451560>] ? copy_page_to_iter+0x70/0x440
  [<ffffffff811ebeac>] ? pagecache_get_page+0x2c/0x290
  [<ffffffff811edaeb>] generic_file_read_iter+0x26b/0x770
  [<ffffffff81285e32>] __vfs_read+0xe2/0x140
  [<ffffffff81286378>] vfs_read+0x98/0x140
  [<ffffffff812878c8>] SyS_read+0x58/0xc0
  [<ffffffff81884dbc>] entry_SYSCALL_64_fastpath+0x1f/0xbd

After:

  [<ffffffff8143c243>] dump_stack+0x85/0xc2
  [<ffffffff81073596>] __do_page_fault+0x576/0x5a0
  [<ffffffff8107369c>] trace_do_page_fault+0x5c/0x2e0
  [<ffffffff8106d83c>] do_async_page_fault+0x2c/0xa0
  [<ffffffff81887422>] async_page_fault+0x32/0x40
  [<ffffffff81887861>] pt_regs+0x1/0x10
  [<ffffffff81451560>] ? copy_page_to_iter+0x70/0x440
  [<ffffffff811ebeac>] ? pagecache_get_page+0x2c/0x290
  [<ffffffff811edaeb>] generic_file_read_iter+0x26b/0x770
  [<ffffffff81285e32>] __vfs_read+0xe2/0x140
  [<ffffffff81286378>] vfs_read+0x98/0x140
  [<ffffffff812878c8>] SyS_read+0x58/0xc0
  [<ffffffff81884dc6>] entry_SYSCALL_64_fastpath+0x29/0xdb
  [<ffffffff81887861>] pt_regs+0x1/0x10

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

arch/x86/entry/calling.h +2 -0

index 9a9e588..f54886a 100644
@@ -201,6 +201,32 @@ For 32-bit we have the following conventions - kernel is built with
        .byte 0xf1
        .endm
 
+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame

arch/x86/entry/entry_64.S +1 -0

@@ -199,6 +199,7 @@ entry_SYSCALL_64_fastpath:
        ja      1f                              /* return -ENOSYS (already in pt_regs->ax) */
        movq    %r10, %rcx
 
+       CREATE_PT_REGS_FRAME
        /*
         * This call instruction is handled specially in stub_ptregs_64.
         * It might end up jumping to the slow path.  If it jumps, RAX

Quoted 5 lines · Josh Poimboeuf

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

I think we should do that. The silly sample patch I sent you (or at least that I think I sent you) did that, and it worked nicely.

Quoted 8 lines

arch/x86/entry/calling.h +0 -0

index 9a9e588..f54886a 100644
@@ -201,6 +201,32 @@ For 32-bit we have the following conventions - kernel is built with
        .byte 0xf1
        .endm
 

arch/x86/entry/calling.h For 32-bit we have the following conventions - kernel is built with · line 215

Quoted 12 lines

arch/x86/entry/calling.h +12 -0

+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame
+        * pointer based unwinders to find pt_regs on the stack.
+        */
+       .macro CREATE_PT_REGS_FRAME regs=%rsp
+#ifdef CONFIG_FRAME_POINTER
+       pushq   \regs
+       pushq   $pt_regs+1
+       pushq   %rbp
+       movq    %rsp, %rbp
+#endif
+       .endm

I don't love this part. It's going to hurt performance, and, given that we need to change the unwinder anyway to make it useful, let's just emit a table somewhere in .rodata and use it directly.

Quoted 7 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

Quoted 2 lines

I think we should do that. The silly sample patch I sent you (or at least that I think I sent you) did that, and it worked nicely.

Yeah, we can certainly do something similar to make the unwinder smarter. It should be very simple with this approach: if it finds the pt_regs() function on the stack, the (struct pt_regs *) pointer will be right after it.

Quoted 9 lines

Quoted 9 lines

arch/x86/entry/calling.h +0 -0

index 9a9e588..f54886a 100644
@@ -201,6 +201,32 @@ For 32-bit we have the following conventions - kernel is built with
        .byte 0xf1
        .endm
 

Quoted 16 lines

arch/x86/entry/calling.h For 32-bit we have the following conventions - kernel is built with · line 215

Quoted 12 lines

arch/x86/entry/calling.h +12 -0

+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame
+        * pointer based unwinders to find pt_regs on the stack.
+        */
+       .macro CREATE_PT_REGS_FRAME regs=%rsp
+#ifdef CONFIG_FRAME_POINTER
+       pushq   \regs
+       pushq   $pt_regs+1
+       pushq   %rbp
+       movq    %rsp, %rbp
+#endif
+       .endm

I don't love this part. It's going to hurt performance, and, given that we need to change the unwinder anyway to make it useful, let's just emit a table somewhere in .rodata and use it directly.

I'm not sure about the idea of a table. I get the feeling it would add more complexity to both the entry code and the unwinder. How would you specify the pt_regs location when it's on a different stack? (See the interrupt macro: non-nested interrupts will place pt_regs on the task stack before switching to the irq stack.)

If you're worried about performance, I can remove the syscall annotations. They're optional anyway, since the pt_regs is always at the same place on the stack for syscalls.

I think three extra pushes wouldn't be a performance issue for interrupts/exceptions. And they'll go away when we finally bury CONFIG_FRAME_POINTER.

Quoted 11 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

I think we should do that. The silly sample patch I sent you (or at least that I think I sent you) did that, and it worked nicely.

Quoted 4 lines

Yeah, we can certainly do something similar to make the unwinder smarter. It should be very simple with this approach: if it finds the pt_regs() function on the stack, the (struct pt_regs *) pointer will be right after it.

That seems barely easier than checking if it finds a function in .entry that's marked on the stack,

and the latter has no runtime cost.

Quoted 5 lines

I'm not sure about the idea of a table. I get the feeling it would add more complexity to both the entry code and the unwinder. How would you specify the pt_regs location when it's on a different stack? (See the interrupt macro: non-nested interrupts will place pt_regs on the task stack before switching to the irq stack.)

Hmm. I need to think about the interrupt stack case a bit. Although the actual top of the interrupt stack has a nearly fixed format, and I have old patches to clean it up and make it actually be fixed. I'll try to dust those off and resend them soon.

Quoted 7 lines

If you're worried about performance, I can remove the syscall annotations. They're optional anyway, since the pt_regs is always at the same place on the stack for syscalls.

I think three extra pushes wouldn't be a performance issue for interrupts/exceptions. And they'll go away when we finally bury CONFIG_FRAME_POINTER.

I bet we'll always need to support CONFIG_FRAME_POINTER for some embedded systems.

I'll play with this a bit.

Quoted 12 lines · Andy Lutomirski

Quoted 11 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

I think we should do that. The silly sample patch I sent you (or at least that I think I sent you) did that, and it worked nicely.

Quoted 7 lines

Quoted 4 lines

Yeah, we can certainly do something similar to make the unwinder smarter. It should be very simple with this approach: if it finds the pt_regs() function on the stack, the (struct pt_regs *) pointer will be right after it.

That seems barely easier than checking if it finds a function in .entry that's marked on the stack,

Don't forget you'd also have to look up the function's pt_regs offset in the table.

Quoted 1 line

and the latter has no runtime cost.

Well, I had been assuming the three extra pushes and one extra pop for interrupts would be negligible, but I'm definitely no expert there. Any idea how I can measure it?

Quoted 7 lines

Quoted 6 lines

I'm not sure about the idea of a table. I get the feeling it would add more complexity to both the entry code and the unwinder. How would you specify the pt_regs location when it's on a different stack? (See the interrupt macro: non-nested interrupts will place pt_regs on the task stack before switching to the irq stack.)

Quoted 4 lines

Hmm. I need to think about the interrupt stack case a bit. Although the actual top of the interrupt stack has a nearly fixed format, and I have old patches to clean it up and make it actually be fixed. I'll try to dust those off and resend them soon.

How would that solve the problem? Would pt_regs be moved or copied to the irq stack?

Quoted 11 lines

Quoted 8 lines

If you're worried about performance, I can remove the syscall annotations. They're optional anyway, since the pt_regs is always at the same place on the stack for syscalls.

I think three extra pushes wouldn't be a performance issue for interrupts/exceptions. And they'll go away when we finally bury CONFIG_FRAME_POINTER.

I bet we'll always need to support CONFIG_FRAME_POINTER for some embedded systems.

Yeah, probably.

Quoted 1 line

I'll play with this a bit.

Thanks, looking forward to seeing what you come up with.

--
Josh

Quoted 26 lines · Josh Poimboeuf

Quoted 12 lines · Andy Lutomirski

Quoted 11 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

I think we should do that. The silly sample patch I sent you (or at least that I think I sent you) did that, and it worked nicely.

Quoted 7 lines

Quoted 4 lines

Yeah, we can certainly do something similar to make the unwinder smarter. It should be very simple with this approach: if it finds the pt_regs() function on the stack, the (struct pt_regs *) pointer will be right after it.

That seems barely easier than checking if it finds a function in .entry that's marked on the stack,

Don't forget you'd also have to look up the function's pt_regs offset in the table.

Quoted 1 line

and the latter has no runtime cost.

Quoted 3 lines

Well, I had been assuming the three extra pushes and one extra pop for interrupts would be negligible, but I'm definitely no expert there. Any idea how I can measure it?

I think it would be negligible, at least for interrupts, since interrupts are already extremely expensive. But I don't love adding assembly code that makes them even slower.

The real thing I dislike about this approach is that it's not a normal stack frame, so you need code in the unwinder to unwind through it correctly, which makes me think that you're not saving much complexity by adding the pushes. But maybe I'm wrong.

Quoted 6 lines

Quoted 6 lines

Quoted 5 lines

I'm not sure about the idea of a table. I get the feeling it would add more complexity to both the entry code and the unwinder. How would you specify the pt_regs location when it's on a different stack? (See the interrupt macro: non-nested interrupts will place pt_regs on the task stack before switching to the irq stack.)

Quoted 7 lines

Quoted 4 lines

Hmm. I need to think about the interrupt stack case a bit. Although the actual top of the interrupt stack has a nearly fixed format, and I have old patches to clean it up and make it actually be fixed. I'll try to dust those off and resend them soon.

How would that solve the problem? Would pt_regs be moved or copied to the irq stack?

Hmm.

Maybe the right way would be to unwind off the IRQ stack in two steps. Step one would be to figure out that you're on the IRQ stack and pop your way off it. Step two would be to find pt_regs.

But that could be rather nasty to implement. Maybe what we actually want to do is this:

First, apply this thing:

https://git.kernel.org/cgit/linux/kernel/git/luto/linux.git/commit/?h=x86/entry_ist&id=2231ec7e0bcc1a2bc94a17081511ab54cc6badd1

that gives us a common format for the IRQ stack.

Second, use my idea of making a table of offsets to pt_regs, so we'd have, roughly:

ENTER_IRQ_STACK old_rsp=%r11
call __do_softirq
ANNOTATE_IRQSTACK_PTREGS_CALL offset=0
LEAVE_IRQ_STACK

the idea here is that offset=0 means that there is no offset beyond that implied by ENTER_IRQ_STACK. What actually gets written to the table is offset 8, because ENTER_IRQ_STACK itself does one push.

So far, this has no runtime overhead at all.

Then, in the unwinder, the logic becomes:

If the return address is annotated in the ptregs entry table, look up the offset. If the offset is in bounds, then use it. If the offset is out of bounds and we're on the IRQ stack, then unwind the ENTER_IRQ_STACK as well.

Does that seem reasonable? I can try to implement it and see what it looks like.

I think it would be negligible, at least for interrupts, since interrupts are already extremely expensive. But I don't love adding assembly code that makes them even slower. The real thing I dislike about this approach is that it's not a normal stack frame, so you need code in the unwinder to unwind through it correctly, which makes me think that you're not saving much complexity by adding the pushes.

Quoted 6 lines · Andy Lutomirski

I think it would be negligible, at least for interrupts, since interrupts are already extremely expensive. But I don't love adding assembly code that makes them even slower. The real thing I dislike about this approach is that it's not a normal stack frame, so you need code in the unwinder to unwind through it correctly, which makes me think that you're not saving much complexity by adding the pushes.

I fail to see what is so special about the stack frame; it's in fact pretty normal.

It has added semantic value for "those who know", but the others will (pretty much correctly) consider it to be a stackframe from a function call, and be done with it.

What am I missing?

Quoted 82 lines · Andy Lutomirski

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion. But this is pretty simple and performance is already abysmal in most handlers.

Quoted 5 lines

There's an added benefit to using a separate section, though: we could also annotate the calls with what type of entry they were so the unwinder could print it out nicely.

I could be convinced either way.

Ok, I took a stab at this. See the patch below.

In addition to annotating interrupt/exception pt_regs frames, I also annotated all the syscall pt_regs, for consistency.

As you mentioned, it will affect performance a bit, but I think it will be insignificant.

I think I like this approach better than putting the interrupt/idtentry's in a special section, because this is much more precise. Especially now that I'm annotating pt_regs syscalls.

Also I think with a few minor changes we could implement your idea of annotating the calls with what type of entry they are. But I don't think that's really needed, because the name of the interrupt/idtentry is already on the stack trace.

Before:

  [<ffffffff8143c243>] dump_stack+0x85/0xc2
  [<ffffffff81073596>] __do_page_fault+0x576/0x5a0
  [<ffffffff8107369c>] trace_do_page_fault+0x5c/0x2e0
  [<ffffffff8106d83c>] do_async_page_fault+0x2c/0xa0
  [<ffffffff81887058>] async_page_fault+0x28/0x30
  [<ffffffff81451560>] ? copy_page_to_iter+0x70/0x440
  [<ffffffff811ebeac>] ? pagecache_get_page+0x2c/0x290
  [<ffffffff811edaeb>] generic_file_read_iter+0x26b/0x770
  [<ffffffff81285e32>] __vfs_read+0xe2/0x140
  [<ffffffff81286378>] vfs_read+0x98/0x140
  [<ffffffff812878c8>] SyS_read+0x58/0xc0
  [<ffffffff81884dbc>] entry_SYSCALL_64_fastpath+0x1f/0xbd

After:

  [<ffffffff8143c243>] dump_stack+0x85/0xc2
  [<ffffffff81073596>] __do_page_fault+0x576/0x5a0
  [<ffffffff8107369c>] trace_do_page_fault+0x5c/0x2e0
  [<ffffffff8106d83c>] do_async_page_fault+0x2c/0xa0
  [<ffffffff81887422>] async_page_fault+0x32/0x40
  [<ffffffff81887861>] pt_regs+0x1/0x10
  [<ffffffff81451560>] ? copy_page_to_iter+0x70/0x440
  [<ffffffff811ebeac>] ? pagecache_get_page+0x2c/0x290
  [<ffffffff811edaeb>] generic_file_read_iter+0x26b/0x770
  [<ffffffff81285e32>] __vfs_read+0xe2/0x140
  [<ffffffff81286378>] vfs_read+0x98/0x140
  [<ffffffff812878c8>] SyS_read+0x58/0xc0
  [<ffffffff81884dc6>] entry_SYSCALL_64_fastpath+0x29/0xdb
  [<ffffffff81887861>] pt_regs+0x1/0x10

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

arch/x86/entry/entry_64.S +1 -0

@@ -199,6 +199,7 @@ entry_SYSCALL_64_fastpath:
        ja      1f                              /* return -ENOSYS (already in pt_regs->ax) */
        movq    %r10, %rcx
 
+       CREATE_PT_REGS_FRAME
        /*
         * This call instruction is handled specially in stub_ptregs_64.
         * It might end up jumping to the slow path.  If it jumps, RAX

arch/x86/entry/entry_64.S +1 -1

        jmp     return_from_SYSCALL_64
 
 entry_SYSCALL64_slow_path:
        /* IRQs are off. */
        SAVE_EXTRA_REGS
        movq    %rsp, %rdi
-       call    do_syscall_64           /* returns with IRQs disabled */
+       CALL_HANDLER do_syscall_64      /* returns with IRQs disabled */
 
 return_from_SYSCALL_64:
        RESTORE_EXTRA_REGS

Quoted 138 lines · Josh Poimboeuf

Quoted 82 lines · Andy Lutomirski

Quoted 44 lines · Josh Poimboeuf

Quoted 28 lines · Andy Lutomirski

Quoted 19 lines · Josh Poimboeuf

Quoted 9 lines · Andy Lutomirski

Quoted 5 lines · Josh Poimboeuf

Quoted 2 lines

I suppose we could try to rejigger the code so that rbp points to pt_regs or similar.

I think we should avoid doing something like that because it would break gdb and all the other unwinders who don't know about it.

How so?

Quoted 7 lines

Currently, rbp in the entry code is meaningless. I'm suggesting that, when we do, for example, 'call \do_sym' in idtentry, we point rbp to the pt_regs. Currently it points to something stale (which the dump_stack code might be relying on. Hmm.) But it's probably also safe to assume that if you unwind to the 'call \do_sym', then pt_regs is the next thing on the stack, so just doing the section thing would work.

Quoted 5 lines

Yes, rbp is meaningless on the entry from user space. But if an in-kernel interrupt occurs (e.g. page fault, preemption) and you have nested entry, rbp keeps its old value, right? So the unwinder can walk past the nested entry frame and keep going until it gets to the original entry.

Yes.

Quoted 8 lines

It would be nice if we could do better, though, and actually notice the pt_regs and identify the entry. For example, I'd love to see "page fault, RIP=xyz" printed in the middle of a stack dump on a crash.

Also, I think that just following rbp links will lose the actual function that took the page fault (or whatever function pt_regs->ip actually points to).

Hm. I think we could fix all that in a more standard way. Whenever a new pt_regs frame gets saved on entry, we could also create a new stack frame which points to a fake kernel_entry() function. That would tell the unwinder there's a pt_regs frame without otherwise breaking frame pointers across the frame.

Quoted 4 lines

Then I guess we wouldn't need my other solution of putting the idt entries in a special section.

How does that sound?

Let me try to understand.

The normal call sequence is call; push %rbp; mov %rsp, %rbp. So rbp points to (prev rbp, prev rip) on the stack, and you can follow the chain back. Right now, on a user access page fault or similar, we have rbp (probably) pointing to the interrupted frame, and the interrupted rip isn't saved anywhere that a naive unwinder can find it. (It's in pt_regs, but the rbp chain skips right over that.)

We could change the entry code so that an interrupt / idtentry does:

push pt_regs
push kernel_entry
push %rbp
mov %rsp, %rbp
call handler
pop %rbp
addq $8, %rsp

or similar. That would make it appear that the actual C handler was caused by a dummy function "kernel_entry". Now the unwinder would get to kernel_entry, but it *still* wouldn't find its way to the calling frame, which only solves part of the problem. We could at least teach the unwinder how kernel_entry works and let it decode pt_regs to continue unwinding. This would be nice, and I think it could work.

I think I like this, except that, if it used a separate section, it could potentially be faster, as, for each actual entry type, the offset from the C handler frame to pt_regs is a foregone conclusion. But this is pretty simple and performance is already abysmal in most handlers.

Quoted 5 lines

There's an added benefit to using a separate section, though: we could also annotate the calls with what type of entry they were so the unwinder could print it out nicely.

I could be convinced either way.

Ok, I took a stab at this. See the patch below.

In addition to annotating interrupt/exception pt_regs frames, I also annotated all the syscall pt_regs, for consistency.

As you mentioned, it will affect performance a bit, but I think it will be insignificant.

I think I like this approach better than putting the interrupt/idtentry's in a special section, because this is much more precise. Especially now that I'm annotating pt_regs syscalls.

Also I think with a few minor changes we could implement your idea of annotating the calls with what type of entry they are. But I don't think that's really needed, because the name of the interrupt/idtentry is already on the stack trace.

Before:

  [<ffffffff8143c243>] dump_stack+0x85/0xc2
  [<ffffffff81073596>] __do_page_fault+0x576/0x5a0
  [<ffffffff8107369c>] trace_do_page_fault+0x5c/0x2e0
  [<ffffffff8106d83c>] do_async_page_fault+0x2c/0xa0
  [<ffffffff81887058>] async_page_fault+0x28/0x30
  [<ffffffff81451560>] ? copy_page_to_iter+0x70/0x440
  [<ffffffff811ebeac>] ? pagecache_get_page+0x2c/0x290
  [<ffffffff811edaeb>] generic_file_read_iter+0x26b/0x770
  [<ffffffff81285e32>] __vfs_read+0xe2/0x140
  [<ffffffff81286378>] vfs_read+0x98/0x140
  [<ffffffff812878c8>] SyS_read+0x58/0xc0
  [<ffffffff81884dbc>] entry_SYSCALL_64_fastpath+0x1f/0xbd

After:

  [<ffffffff8143c243>] dump_stack+0x85/0xc2
  [<ffffffff81073596>] __do_page_fault+0x576/0x5a0
  [<ffffffff8107369c>] trace_do_page_fault+0x5c/0x2e0
  [<ffffffff8106d83c>] do_async_page_fault+0x2c/0xa0
  [<ffffffff81887422>] async_page_fault+0x32/0x40
  [<ffffffff81887861>] pt_regs+0x1/0x10
  [<ffffffff81451560>] ? copy_page_to_iter+0x70/0x440
  [<ffffffff811ebeac>] ? pagecache_get_page+0x2c/0x290
  [<ffffffff811edaeb>] generic_file_read_iter+0x26b/0x770
  [<ffffffff81285e32>] __vfs_read+0xe2/0x140
  [<ffffffff81286378>] vfs_read+0x98/0x140
  [<ffffffff812878c8>] SyS_read+0x58/0xc0
  [<ffffffff81884dc6>] entry_SYSCALL_64_fastpath+0x29/0xdb
  [<ffffffff81887861>] pt_regs+0x1/0x10

Quoted 5 lines

Note this example is with today's unwinder. It could be made smarter to get the RIP from the pt_regs so the '?' could be removed from copy_page_to_iter().

Thoughts?

Maybe I'm coming around to liking this idea.

In an ideal world (DWARF support, high-quality unwinder, nice pretty printer, etc), unwinding across a kernel exception would look like:

- some_func
- some_other_func
- do_page_fault
- page_fault

After page_fault, the next unwind step takes us to the faulting RIP (faulting_func) and reports that all GPRs are known. It should probably learn this fact from DWARF if DWARF is available, instead of directly decoding pt_regs, due to a few funny cases in which pt_regs may be incomplete. A nice pretty printer could now print all the regs.

- faulting_func
- etc.

For this to work, we don't actually need the unwinder to explicitly know where pt_regs is.

Food for thought, though: if user code does SYSENTER with TF set, you'll end up with partial pt_regs. There's nothing the kernel can do about it. DWARF will handle it without any fanfare, but I don't know if it's going to cause trouble for you pre-DWARF.

I'm also not sure it makes sense to apply this before the unwinder that can consume it is ready. Maybe, if it would be consistent with your plans, it would make sense to rewrite the unwinder first, then apply this and teach live patching to use the new unwinder, and *then* add DWARF support?

arch/x86/entry/calling.h For 32-bit we have the following conventions - kernel is built with · line 211

Quoted 8 lines

arch/x86/entry/calling.h +8 -0

+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame
+        * pointer based unwinders to find pt_regs on the stack.
+        */
+       .macro CREATE_PT_REGS_FRAME regs=%rsp
+#ifdef CONFIG_FRAME_POINTER
+       pushq   \regs
+       pushq   $pt_regs+1

Why the +1?

arch/x86/entry/calling.h For 32-bit we have the following conventions - kernel is built with · line 215

Quoted 4 lines

arch/x86/entry/calling.h +4 -0

+       pushq   %rbp
+       movq    %rsp, %rbp
+#endif
+       .endm

I keep wanting this to be only two pushes and to fudge rbp to make it work, but I don't see a good way. But let's call it CREATE_NESTED_ENTRY_FRAME or something, and let's rename pt_regs to nested_frame or similar.

arch/x86/entry/calling.h For 32-bit we have the following conventions - kernel is built with · line 228

Quoted 6 lines

arch/x86/entry/calling.h +6 -0

+
+       .macro CALL_HANDLER handler regs=%rsp
+       CREATE_PT_REGS_FRAME \regs
+       call    \handler
+       REMOVE_PT_REGS_FRAME
+       .endm

I think I'd rather open-code this everywhere. It'll make it clearer what's going on.

Quoted 12 lines

arch/x86/entry/entry_64.S +1 -0

@@ -199,6 +199,7 @@ entry_SYSCALL_64_fastpath:
        ja      1f                              /* return -ENOSYS (already in pt_regs->ax) */
        movq    %r10, %rcx
 
+       CREATE_PT_REGS_FRAME
        /*
         * This call instruction is handled specially in stub_ptregs_64.
         * It might end up jumping to the slow path.  If it jumps, RAX

@@ -207,6 +208,8 @@ entry_SYSCALL_64_fastpath:
        call    *sys_call_table(, %rax, 8)
 .Lentry_SYSCALL_64_after_fastpath_call:
 

Review entry_SYSCALL_64_fastpath: · line 212

Quoted 2 lines

(quoted diff) +2 -0

+       REMOVE_PT_REGS_FRAME
+

As discussed, let's get rid of this bit.

Quoted 4 lines

arch/x86/entry/entry_64.S +0 -0

        movq    %rax, RAX(%rsp)
 1:
 

arch/x86/entry/entry_64.S entry_SYSCALL_64_fastpath: · line 244

Quoted 6 lines

arch/x86/entry/entry_64.S +1 -1

@@ -238,14 +241,14 @@ entry_SYSCALL_64_fastpath:
        ENABLE_INTERRUPTS(CLBR_NONE)
        SAVE_EXTRA_REGS
        movq    %rsp, %rdi
-       call    syscall_return_slowpath /* returns with IRQs disabled */
+       CALL_HANDLER syscall_return_slowpath    /* returns with IRQs disabled */

and this.

Quoted 10 lines

arch/x86/entry/entry_64.S +1 -1

        jmp     return_from_SYSCALL_64
 
 entry_SYSCALL64_slow_path:
        /* IRQs are off. */
        SAVE_EXTRA_REGS
        movq    %rsp, %rdi
-       call    do_syscall_64           /* returns with IRQs disabled */
+       CALL_HANDLER do_syscall_64      /* returns with IRQs disabled */
 

arch/x86/entry/entry_64.S ENTRY(stub_ptregs_64) · line 350

Quoted 7 lines

arch/x86/entry/entry_64.S +1 -0

 return_from_SYSCALL_64:
        RESTORE_EXTRA_REGS

@@ -344,6 +347,7 @@ ENTRY(stub_ptregs_64)
        DISABLE_INTERRUPTS(CLBR_NONE)
        TRACE_IRQS_OFF
        popq    %rax
+       REMOVE_PT_REGS_FRAME

This will be less mysterious if you open-code the macros. Also, I think you have to, some return_from_SYSCALL_64 needs to be directly after the actual call instruction. (But if you get rid of the hunks above, I think this goes away too, so this may be moot.)

arch/x86/entry/entry_64.S END(ptregs_\func) · line 380

Quoted 8 lines

arch/x86/entry/entry_64.S +1 -1

 1:

@@ -372,7 +376,7 @@ END(ptregs_\func)
 ENTRY(ret_from_fork)
        LOCK ; btr $TIF_FORK, TI_flags(%r8)
 
-       call    schedule_tail                   /* rdi: 'prev' task parameter */
+       CALL_HANDLER schedule_tail              /* rdi: 'prev' task parameter */
 

If you end up making the unwinder smart enough to notice that rsp is just below pt_regs, then this can go away. It's harmless, though.

Quoted 5 lines

arch/x86/entry/entry_64.S +0 -0

        testb   $3, CS(%rsp)                    /* from kernel_thread? */
        jnz     1f

@@ -385,8 +389,9 @@ ENTRY(ret_from_fork)
         * parameter to be passed in RBP.  The called function is permitted
         * to call do_execve and thereby jump to user mode.

arch/x86/entry/entry_64.S ENTRY(ret_from_fork) · line 394

Quoted 5 lines

arch/x86/entry/entry_64.S +2 -1

         */
+       movq    RBX(%rsp), %rbx
        movq    RBP(%rsp), %rdi
-       call    *RBX(%rsp)
+       CALL_HANDLER *%rbx

Does using a register like this actually save any code size? Admittedly, it's a bit cleaner.

arch/x86/entry/entry_64.S ENTRY(ignore_sysret) · line 1436

Quoted 8 lines

arch/x86/entry/entry_64.S +8 -0

+
+/* fake function which allows stack unwinders to detect pt_regs frames */
+#ifdef CONFIG_FRAME_POINTER
+ENTRY(pt_regs)
+       nop
+       nop
+ENDPROC(pt_regs)
+#endif /* CONFIG_FRAME_POINTER */

Why is this two bytes long? Is there some reason it has to be more than one byte?

Quoted 1 line

Maybe I'm coming around to liking this idea.

Ok, good :-)

Quoted 15 lines

In an ideal world (DWARF support, high-quality unwinder, nice pretty printer, etc), unwinding across a kernel exception would look like:

- some_func
- some_other_func
- do_page_fault
- page_fault

After page_fault, the next unwind step takes us to the faulting RIP (faulting_func) and reports that all GPRs are known. It should probably learn this fact from DWARF if DWARF is available, instead of directly decoding pt_regs, due to a few funny cases in which pt_regs may be incomplete. A nice pretty printer could now print all the regs.

Quoted 5 lines

- faulting_func
- etc.

For this to work, we don't actually need the unwinder to explicitly know where pt_regs is.

That's true (but only for DWARF).

Quoted 4 lines

Food for thought, though: if user code does SYSENTER with TF set, you'll end up with partial pt_regs. There's nothing the kernel can do about it. DWARF will handle it without any fanfare, but I don't know if it's going to cause trouble for you pre-DWARF.

In this case it should see the stack pointer is past the pt_regs offset, so it would just report it as an empty stack.

Quoted 6 lines

I'm also not sure it makes sense to apply this before the unwinder that can consume it is ready. Maybe, if it would be consistent with your plans, it would make sense to rewrite the unwinder first, then apply this and teach live patching to use the new unwinder, and *then* add DWARF support?

For the purposes of livepatch, the reliable unwinder needs to detect whether an interrupt/exception pt_regs frame exists on a sleeping task (or current). This patch would allow us to do that.

So my preferred order of doing things would be:

1) Brian Gerst's switch_to() cleanup and any related unwinder fixes
2) this patch for annotating pt_regs stack frames
3) reliable unwinder, similar to what I already posted, except it relies on this patch instead of PF_PREEMPT_IRQ, and knows how to deal with the new inactive task frame format of #1
4) livepatch consistency model which uses the reliable unwinder
5) rewrite unwinder, and port all users to the new interface
6) add DWARF unwinder

1-4 are pretty much already written, whereas 5 and 6 will take considerably more work.

Quoted 10 lines

Quoted 9 lines

arch/x86/entry/calling.h +8 -0

+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame
+        * pointer based unwinders to find pt_regs on the stack.
+        */
+       .macro CREATE_PT_REGS_FRAME regs=%rsp
+#ifdef CONFIG_FRAME_POINTER
+       pushq   \regs
+       pushq   $pt_regs+1

Quoted 1 line

Why the +1?

Some unwinders like gdb are smart enough to report the function which contains the instruction *before* the return address. Without the +1, they would show the wrong function.

Quoted 6 lines

Quoted 5 lines

arch/x86/entry/calling.h +4 -0

+       pushq   %rbp
+       movq    %rsp, %rbp
+#endif
+       .endm

Quoted 4 lines

I keep wanting this to be only two pushes and to fudge rbp to make it work, but I don't see a good way. But let's call it CREATE_NESTED_ENTRY_FRAME or something, and let's rename pt_regs to nested_frame or similar.

Or, if we aren't going to annotate syscall pt_regs, we could give it a more specific name. CREATE_INTERRUPT_FRAME and interrupt_frame()?

Quoted 11 lines

arch/x86/entry/entry_64.S ENTRY(ignore_sysret) · line 1436

Quoted 8 lines

arch/x86/entry/entry_64.S +8 -0

+
+/* fake function which allows stack unwinders to detect pt_regs frames */
+#ifdef CONFIG_FRAME_POINTER
+ENTRY(pt_regs)
+       nop
+       nop
+ENDPROC(pt_regs)
+#endif /* CONFIG_FRAME_POINTER */

Why is this two bytes long? Is there some reason it has to be more than one byte?

Similar to above, this is related to the need to support various unwinders. Whether the unwinder displays the ret_addr or the instruction preceding it, either way the instruction needs to be inside the function for the function to be reported.

Quoted 27 lines · Josh Poimboeuf

Quoted 1 line

Maybe I'm coming around to liking this idea.

Ok, good :-)

Quoted 15 lines

In an ideal world (DWARF support, high-quality unwinder, nice pretty printer, etc), unwinding across a kernel exception would look like:

- some_func
- some_other_func
- do_page_fault
- page_fault

After page_fault, the next unwind step takes us to the faulting RIP (faulting_func) and reports that all GPRs are known. It should probably learn this fact from DWARF if DWARF is available, instead of directly decoding pt_regs, due to a few funny cases in which pt_regs may be incomplete. A nice pretty printer could now print all the regs.

Quoted 5 lines

- faulting_func
- etc.

For this to work, we don't actually need the unwinder to explicitly know where pt_regs is.

That's true (but only for DWARF).

Quoted 7 lines

Quoted 4 lines

Food for thought, though: if user code does SYSENTER with TF set, you'll end up with partial pt_regs. There's nothing the kernel can do about it. DWARF will handle it without any fanfare, but I don't know if it's going to cause trouble for you pre-DWARF.

In this case it should see the stack pointer is past the pt_regs offset, so it would just report it as an empty stack.

OK

Quoted 22 lines

Quoted 6 lines

I'm also not sure it makes sense to apply this before the unwinder that can consume it is ready. Maybe, if it would be consistent with your plans, it would make sense to rewrite the unwinder first, then apply this and teach live patching to use the new unwinder, and *then* add DWARF support?

For the purposes of livepatch, the reliable unwinder needs to detect whether an interrupt/exception pt_regs frame exists on a sleeping task (or current). This patch would allow us to do that.

So my preferred order of doing things would be:

1) Brian Gerst's switch_to() cleanup and any related unwinder fixes
2) this patch for annotating pt_regs stack frames
3) reliable unwinder, similar to what I already posted, except it relies on this patch instead of PF_PREEMPT_IRQ, and knows how to deal with the new inactive task frame format of #1
4) livepatch consistency model which uses the reliable unwinder
5) rewrite unwinder, and port all users to the new interface
6) add DWARF unwinder

Quoted 2 lines

1-4 are pretty much already written, whereas 5 and 6 will take considerably more work.

Fair enough.

Quoted 10 lines

Quoted 10 lines

Quoted 9 lines

(quoted diff) +8 -0

+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame
+        * pointer based unwinders to find pt_regs on the stack.
+        */
+       .macro CREATE_PT_REGS_FRAME regs=%rsp
+#ifdef CONFIG_FRAME_POINTER
+       pushq   \regs
+       pushq   $pt_regs+1

Quoted 5 lines

Quoted 1 line

Why the +1?

Some unwinders like gdb are smart enough to report the function which contains the instruction *before* the return address. Without the +1, they would show the wrong function.

Lovely. Want to add a comment?

Quoted 6 lines

Quoted 6 lines

Quoted 5 lines

(quoted diff) +4 -0

+       pushq   %rbp
+       movq    %rsp, %rbp
+#endif
+       .endm

Quoted 7 lines

Quoted 4 lines

I keep wanting this to be only two pushes and to fudge rbp to make it work, but I don't see a good way. But let's call it CREATE_NESTED_ENTRY_FRAME or something, and let's rename pt_regs to nested_frame or similar.

Or, if we aren't going to annotate syscall pt_regs, we could give it a more specific name. CREATE_INTERRUPT_FRAME and interrupt_frame()?

CREATE_INTERRUPT_FRAME is confusing because it applies to idtentry, too. CREATE_PT_REGS_FRAME is probably fine.

Quoted 12 lines

Quoted 11 lines

Review

Quoted 8 lines

(quoted diff) +8 -0

+
+/* fake function which allows stack unwinders to detect pt_regs frames */
+#ifdef CONFIG_FRAME_POINTER
+ENTRY(pt_regs)
+       nop
+       nop
+ENDPROC(pt_regs)
+#endif /* CONFIG_FRAME_POINTER */

Why is this two bytes long? Is there some reason it has to be more than one byte?

Quoted 4 lines

Similar to above, this is related to the need to support various unwinders. Whether the unwinder displays the ret_addr or the instruction preceding it, either way the instruction needs to be inside the function for the function to be reported.

OK.

Quoted 112 lines · Andy Lutomirski

Quoted 27 lines · Josh Poimboeuf

Quoted 1 line

Maybe I'm coming around to liking this idea.

Ok, good :-)

Quoted 15 lines

In an ideal world (DWARF support, high-quality unwinder, nice pretty printer, etc), unwinding across a kernel exception would look like:

- some_func
- some_other_func
- do_page_fault
- page_fault

After page_fault, the next unwind step takes us to the faulting RIP (faulting_func) and reports that all GPRs are known. It should probably learn this fact from DWARF if DWARF is available, instead of directly decoding pt_regs, due to a few funny cases in which pt_regs may be incomplete. A nice pretty printer could now print all the regs.

Quoted 5 lines

- faulting_func
- etc.

For this to work, we don't actually need the unwinder to explicitly know where pt_regs is.

That's true (but only for DWARF).

Quoted 7 lines

Quoted 4 lines

Food for thought, though: if user code does SYSENTER with TF set, you'll end up with partial pt_regs. There's nothing the kernel can do about it. DWARF will handle it without any fanfare, but I don't know if it's going to cause trouble for you pre-DWARF.

In this case it should see the stack pointer is past the pt_regs offset, so it would just report it as an empty stack.

OK

Quoted 22 lines

Quoted 6 lines

I'm also not sure it makes sense to apply this before the unwinder that can consume it is ready. Maybe, if it would be consistent with your plans, it would make sense to rewrite the unwinder first, then apply this and teach live patching to use the new unwinder, and *then* add DWARF support?

For the purposes of livepatch, the reliable unwinder needs to detect whether an interrupt/exception pt_regs frame exists on a sleeping task (or current). This patch would allow us to do that.

So my preferred order of doing things would be:

1) Brian Gerst's switch_to() cleanup and any related unwinder fixes
2) this patch for annotating pt_regs stack frames
3) reliable unwinder, similar to what I already posted, except it relies on this patch instead of PF_PREEMPT_IRQ, and knows how to deal with the new inactive task frame format of #1
4) livepatch consistency model which uses the reliable unwinder
5) rewrite unwinder, and port all users to the new interface
6) add DWARF unwinder

Quoted 2 lines

1-4 are pretty much already written, whereas 5 and 6 will take considerably more work.

Fair enough.

Quoted 10 lines

Quoted 10 lines

Quoted 9 lines

(quoted diff) +8 -0

+       /*
+        * Create a stack frame for the saved pt_regs.  This allows frame
+        * pointer based unwinders to find pt_regs on the stack.
+        */
+       .macro CREATE_PT_REGS_FRAME regs=%rsp
+#ifdef CONFIG_FRAME_POINTER
+       pushq   \regs
+       pushq   $pt_regs+1

Quoted 5 lines

Quoted 1 line

Why the +1?

Some unwinders like gdb are smart enough to report the function which contains the instruction *before* the return address. Without the +1, they would show the wrong function.

Lovely. Want to add a comment?

Quoted 6 lines

Quoted 6 lines

Quoted 5 lines

arch/x86/entry/calling.h +4 -0

+       pushq   %rbp
+       movq    %rsp, %rbp
+#endif
+       .endm

Quoted 7 lines

Quoted 4 lines

I keep wanting this to be only two pushes and to fudge rbp to make it work, but I don't see a good way. But let's call it CREATE_NESTED_ENTRY_FRAME or something, and let's rename pt_regs to nested_frame or similar.

Or, if we aren't going to annotate syscall pt_regs, we could give it a more specific name. CREATE_INTERRUPT_FRAME and interrupt_frame()?

CREATE_INTERRUPT_FRAME is confusing because it applies to idtentry, too. CREATE_PT_REGS_FRAME is probably fine.

Quoted 12 lines

Quoted 11 lines

arch/x86/entry/entry_64.S ENTRY(ignore_sysret) · line 1469

Quoted 8 lines

arch/x86/entry/entry_64.S +8 -0

+
+/* fake function which allows stack unwinders to detect pt_regs frames */
+#ifdef CONFIG_FRAME_POINTER
+ENTRY(pt_regs)
+       nop
+       nop
+ENDPROC(pt_regs)
+#endif /* CONFIG_FRAME_POINTER */

Why is this two bytes long? Is there some reason it has to be more than one byte?

Quoted 6 lines

Quoted 4 lines

Similar to above, this is related to the need to support various unwinders. Whether the unwinder displays the ret_addr or the instruction preceding it, either way the instruction needs to be inside the function for the function to be reported.

OK.

Andy,

So I got a chance to look at this some more. I'm thinking that to make this feature more consistently useful, we shouldn't only annotate pt_regs frames for calls to handlers; other calls should be annotated as
well: preempt_schedule_irq, CALL_enter_from_user_mode, prepare_exit_to_usermode, SWAPGS, TRACE_IRQS_OFF, DISABLE_INTERRUPTS, etc. That way, the unwinder will always be able to find pt_regs from an interrupt/exception, even if starting from one of these other calls.

But then, things get ugly. You have to either setup and tear down the frame for every possible call, or do a higher-level setup/teardown across multiple calls, which invalidates several assumptions in the entry code about the location of pt_regs on the stack.

Also problematic is that several of the macros (like TRACE_IRQS_IRETQ) make assumptions about the location of pt_regs. And they're used by both syscall and interrupt code. So if we didn't create a frame pointer header for syscalls, we'd basically need two versions of the macros: one for irqs/exceptions and one for syscalls.

So I think the cleanest way to handle this is to always allocate two extra registers on the stack in ALLOC_PT_GPREGS_ON_STACK. Then all entry code can assume that pt_regs is at a constant location, and all the above problems go away. Another benefit is that we'd only need two saves instead of three -- the pointer to pt_regs is no longer needed since pt_regs is always immediately after the frame header.

I worked up a patch to implement this -- see below. It writes the frame pointer in all entry paths, including syscalls. This helps keep the code simple.

The downside is a small performance penalty: with getppid()-in-a-loop on my laptop, the average syscall went from 52ns to 53ns, which is about a 2% slowdown. But I doubt it would be measurable in a real-world workload.

It looks like about half the slowdown is due to the extra stack allocation (which presumably adds a little d-cache pressure on the stack memory) and the other half is due to the stack writes.

I could remove the writes from the syscall path but it would only save about half a ns, and it would make the code less robust. Plus it's nice to have the consistency of having *all* pt_regs frames annotated.

Quoted 35 lines

So I got a chance to look at this some more. I'm thinking that to make this feature more consistently useful, we shouldn't only annotate pt_regs frames for calls to handlers; other calls should be annotated as
well: preempt_schedule_irq, CALL_enter_from_user_mode, prepare_exit_to_usermode, SWAPGS, TRACE_IRQS_OFF, DISABLE_INTERRUPTS, etc. That way, the unwinder will always be able to find pt_regs from an interrupt/exception, even if starting from one of these other calls.

But then, things get ugly. You have to either setup and tear down the frame for every possible call, or do a higher-level setup/teardown across multiple calls, which invalidates several assumptions in the entry code about the location of pt_regs on the stack.

Also problematic is that several of the macros (like TRACE_IRQS_IRETQ) make assumptions about the location of pt_regs. And they're used by both syscall and interrupt code. So if we didn't create a frame pointer header for syscalls, we'd basically need two versions of the macros: one for irqs/exceptions and one for syscalls.

So I think the cleanest way to handle this is to always allocate two extra registers on the stack in ALLOC_PT_GPREGS_ON_STACK. Then all entry code can assume that pt_regs is at a constant location, and all the above problems go away. Another benefit is that we'd only need two saves instead of three -- the pointer to pt_regs is no longer needed since pt_regs is always immediately after the frame header.

I worked up a patch to implement this -- see below. It writes the frame pointer in all entry paths, including syscalls. This helps keep the code simple.

The downside is a small performance penalty: with getppid()-in-a-loop on my laptop, the average syscall went from 52ns to 53ns, which is about a 2% slowdown. But I doubt it would be measurable in a real-world workload.

Quoted 7 lines

It looks like about half the slowdown is due to the extra stack allocation (which presumably adds a little d-cache pressure on the stack memory) and the other half is due to the stack writes.

I could remove the writes from the syscall path but it would only save about half a ns, and it would make the code less robust. Plus it's nice to have the consistency of having *all* pt_regs frames annotated.

This is a bit messy, and I'm not really sure that the entry code should be have to operate under constraints like this. Also, convincing myself this works for NMI sounds unpleasant.

Maybe we should go back to my idea of just listing the call sites in a table.

Quoted 43 lines · Andy Lutomirski

Quoted 35 lines

So I got a chance to look at this some more. I'm thinking that to make this feature more consistently useful, we shouldn't only annotate pt_regs frames for calls to handlers; other calls should be annotated as
well: preempt_schedule_irq, CALL_enter_from_user_mode, prepare_exit_to_usermode, SWAPGS, TRACE_IRQS_OFF, DISABLE_INTERRUPTS, etc. That way, the unwinder will always be able to find pt_regs from an interrupt/exception, even if starting from one of these other calls.

But then, things get ugly. You have to either setup and tear down the frame for every possible call, or do a higher-level setup/teardown across multiple calls, which invalidates several assumptions in the entry code about the location of pt_regs on the stack.

Also problematic is that several of the macros (like TRACE_IRQS_IRETQ) make assumptions about the location of pt_regs. And they're used by both syscall and interrupt code. So if we didn't create a frame pointer header for syscalls, we'd basically need two versions of the macros: one for irqs/exceptions and one for syscalls.

So I think the cleanest way to handle this is to always allocate two extra registers on the stack in ALLOC_PT_GPREGS_ON_STACK. Then all entry code can assume that pt_regs is at a constant location, and all the above problems go away. Another benefit is that we'd only need two saves instead of three -- the pointer to pt_regs is no longer needed since pt_regs is always immediately after the frame header.

I worked up a patch to implement this -- see below. It writes the frame pointer in all entry paths, including syscalls. This helps keep the code simple.

The downside is a small performance penalty: with getppid()-in-a-loop on my laptop, the average syscall went from 52ns to 53ns, which is about a 2% slowdown. But I doubt it would be measurable in a real-world workload.

Quoted 7 lines

It looks like about half the slowdown is due to the extra stack allocation (which presumably adds a little d-cache pressure on the stack memory) and the other half is due to the stack writes.

I could remove the writes from the syscall path but it would only save about half a ns, and it would make the code less robust. Plus it's nice to have the consistency of having *all* pt_regs frames annotated.

Quoted 5 lines

This is a bit messy, and I'm not really sure that the entry code should be have to operate under constraints like this. Also, convincing myself this works for NMI sounds unpleasant.

Maybe we should go back to my idea of just listing the call sites in a table.

So are you suggesting something like:

.macro ENTRY_CALL func pt_regs_offset=0
call \func
1: .pushsection .entry_calls, "a"

        .long 1b - .
        .long \pt_regs_offset
        .popsection
        .endm

and then change every call in the entry code to ENTRY_CALL?

Quoted 60 lines · Josh Poimboeuf

Quoted 43 lines · Andy Lutomirski

Quoted 35 lines

So I got a chance to look at this some more. I'm thinking that to make this feature more consistently useful, we shouldn't only annotate pt_regs frames for calls to handlers; other calls should be annotated as
well: preempt_schedule_irq, CALL_enter_from_user_mode, prepare_exit_to_usermode, SWAPGS, TRACE_IRQS_OFF, DISABLE_INTERRUPTS, etc. That way, the unwinder will always be able to find pt_regs from an interrupt/exception, even if starting from one of these other calls.

But then, things get ugly. You have to either setup and tear down the frame for every possible call, or do a higher-level setup/teardown across multiple calls, which invalidates several assumptions in the entry code about the location of pt_regs on the stack.

Also problematic is that several of the macros (like TRACE_IRQS_IRETQ) make assumptions about the location of pt_regs. And they're used by both syscall and interrupt code. So if we didn't create a frame pointer header for syscalls, we'd basically need two versions of the macros: one for irqs/exceptions and one for syscalls.

So I think the cleanest way to handle this is to always allocate two extra registers on the stack in ALLOC_PT_GPREGS_ON_STACK. Then all entry code can assume that pt_regs is at a constant location, and all the above problems go away. Another benefit is that we'd only need two saves instead of three -- the pointer to pt_regs is no longer needed since pt_regs is always immediately after the frame header.

I worked up a patch to implement this -- see below. It writes the frame pointer in all entry paths, including syscalls. This helps keep the code simple.

The downside is a small performance penalty: with getppid()-in-a-loop on my laptop, the average syscall went from 52ns to 53ns, which is about a 2% slowdown. But I doubt it would be measurable in a real-world workload.

Quoted 7 lines

It looks like about half the slowdown is due to the extra stack allocation (which presumably adds a little d-cache pressure on the stack memory) and the other half is due to the stack writes.

I could remove the writes from the syscall path but it would only save about half a ns, and it would make the code less robust. Plus it's nice to have the consistency of having *all* pt_regs frames annotated.

Quoted 5 lines

This is a bit messy, and I'm not really sure that the entry code should be have to operate under constraints like this. Also, convincing myself this works for NMI sounds unpleasant.

Maybe we should go back to my idea of just listing the call sites in a table.

So are you suggesting something like:

.macro ENTRY_CALL func pt_regs_offset=0
call \func
1: .pushsection .entry_calls, "a"

        .long 1b - .
        .long \pt_regs_offset
        .popsection
        .endm

Quoted 1 line

and then change every call in the entry code to ENTRY_CALL?

Yes, exactly, modulo whether the section name is good. hpa is probably the authority on that.

Quoted 11 lines · Andy Lutomirski

Quoted 11 lines

So are you suggesting something like:

.macro ENTRY_CALL func pt_regs_offset=0
call \func
1: .pushsection .entry_calls, "a"

        .long 1b - .
        .long \pt_regs_offset
        .popsection
        .endm

Quoted 4 lines

Quoted 1 line

and then change every call in the entry code to ENTRY_CALL?

Yes, exactly, modulo whether the section name is good. hpa is probably the authority on that.

Well, as you probably know, I don't really like peppering ENTRY_CALL everywhere. :-/

Also I wonder how we could annotate the hypercalls, for example DISABLE_INTERRUPTS actually wraps the call in a push/pop pair.

Quoted 12 lines · Josh Poimboeuf

Quoted 11 lines · Andy Lutomirski

Quoted 11 lines

So are you suggesting something like:

.macro ENTRY_CALL func pt_regs_offset=0
call \func
1: .pushsection .entry_calls, "a"

        .long 1b - .
        .long \pt_regs_offset
        .popsection
        .endm

Quoted 7 lines

Quoted 4 lines

Quoted 1 line

and then change every call in the entry code to ENTRY_CALL?

Yes, exactly, modulo whether the section name is good. hpa is probably the authority on that.

Well, as you probably know, I don't really like peppering ENTRY_CALL everywhere. :-/

Me neither. But at least it's less constraining on the already-fairly-hairy code.

Quoted 1 line

Quoted 2 lines

Also I wonder how we could annotate the hypercalls, for example DISABLE_INTERRUPTS actually wraps the call in a push/pop pair.

Oh, yuck. But forcing all the DISABLE_INTERRUPTS and ENABLE_INTERRUPTS invocations to be in frame pointer regions isn't so great either.

DWARF solves this problem completely and IMO fairly cleanly. Maybe we should add your task flag and then consider removing it again when DWARF happens.

Quoted 28 lines · Andy Lutomirski

Quoted 12 lines · Josh Poimboeuf

Quoted 11 lines · Andy Lutomirski

Quoted 11 lines

So are you suggesting something like:

.macro ENTRY_CALL func pt_regs_offset=0
call \func
1: .pushsection .entry_calls, "a"

        .long 1b - .
        .long \pt_regs_offset
        .popsection
        .endm

Quoted 7 lines

Quoted 4 lines

Quoted 1 line

and then change every call in the entry code to ENTRY_CALL?

Yes, exactly, modulo whether the section name is good. hpa is probably the authority on that.

Well, as you probably know, I don't really like peppering ENTRY_CALL everywhere. :-/

Me neither. But at least it's less constraining on the already-fairly-hairy code.

Quoted 3 lines

Also I wonder how we could annotate the hypercalls, for example DISABLE_INTERRUPTS actually wraps the call in a push/pop pair.

Quoted 3 lines

Oh, yuck. But forcing all the DISABLE_INTERRUPTS and ENABLE_INTERRUPTS invocations to be in frame pointer regions isn't so great either.

Hm, I don't follow this statement. Why not? The more frame pointer coverage, the better, especially if it doesn't add any additional overhead.

Quoted 4 lines

DWARF solves this problem completely and IMO fairly cleanly. Maybe we should add your task flag and then consider removing it again when DWARF happens.

I tend to doubt we'd be able to remove it later. As you said before, many embedded platforms probably won't be able to switch to DWARF, and they'll want to do live patching too.

So which is the least-bad option? To summarize:

1) task flag(s) for preemption and page faults

2) turn pt_regs into a stack frame

3) annotate all calls from entry code in a table

4) encode rbp on entry

They all have their issues, though I'm partial to #2.

Any more hare-brained ideas? :-)

Quoted 8 lines

So which is the least-bad option? To summarize:

1) task flag(s) for preemption and page faults

2) turn pt_regs into a stack frame

3) annotate all calls from entry code in a table

Quoted 5 lines

4) encode rbp on entry

They all have their issues, though I'm partial to #2.

Any more hare-brained ideas? :-)

I'll try to take a closer look at #2 and see just how much I dislike all the stack frame munging.

Also, in principle, it's only the
sleeping calls and the calls that make it into real (non-entry) kernel code that really want to be unwindable through this mechanism.

FWIW, I don't care that much about preserving gdb's partial ability to unwind through pt_regs, especially because gdb really ought to be able to use DWARF, too.

Quoted 8 lines · Andy Lutomirski

Quoted 8 lines

So which is the least-bad option? To summarize:

1) task flag(s) for preemption and page faults

2) turn pt_regs into a stack frame

3) annotate all calls from entry code in a table

Quoted 8 lines

Quoted 5 lines

4) encode rbp on entry

They all have their issues, though I'm partial to #2.

Any more hare-brained ideas? :-)

I'll try to take a closer look at #2 and see just how much I dislike all the stack frame munging.

Ok.

Quoted 3 lines

Also, in principle, it's only the
sleeping calls and the calls that make it into real (non-entry) kernel code that really want to be unwindable through this mechanism.

Yeah, that's true. We could modify options 2 or 3 to be less absolute. Though I think that makes them more prone to future breakage.

Quoted 3 lines

FWIW, I don't care that much about preserving gdb's partial ability to unwind through pt_regs, especially because gdb really ought to be able to use DWARF, too.

Hm, that's a good point. I really don't know if there are any other external tools out there that would care. Maybe we could try option 4 and then see if anybody complains.

Quoted 27 lines · Josh Poimboeuf

Quoted 8 lines · Andy Lutomirski

Quoted 8 lines

So which is the least-bad option? To summarize:

1) task flag(s) for preemption and page faults

2) turn pt_regs into a stack frame

3) annotate all calls from entry code in a table

Quoted 8 lines

Quoted 5 lines

4) encode rbp on entry

They all have their issues, though I'm partial to #2.

Any more hare-brained ideas? :-)

I'll try to take a closer look at #2 and see just how much I dislike all the stack frame munging.

Ok.

Quoted 3 lines

Also, in principle, it's only the
sleeping calls and the calls that make it into real (non-entry) kernel code that really want to be unwindable through this mechanism.

Yeah, that's true. We could modify options 2 or 3 to be less absolute. Though I think that makes them more prone to future breakage.

Quoted 7 lines

Quoted 3 lines

FWIW, I don't care that much about preserving gdb's partial ability to unwind through pt_regs, especially because gdb really ought to be able to use DWARF, too.

Hm, that's a good point. I really don't know if there are any other external tools out there that would care. Maybe we could try option 4 and then see if anybody complains.

I'm starting to think hare-brained option 4 is the way to go. Any external tooling should really be relying on DWARF anyway.

Here's a sneak preview. If this general approach looks ok to you, I'll go ahead and port all the in-tree unwinders and post a proper patch.

Instead of using xor -1 on the pt_regs pointer, I just cleared the high-order bit. That makes the unwinding experience much more pleasant for a human stack walker, and also ensures that anybody trying to dereference it gets slapped with an oops, at least in the 48-bit address space era.

arch/x86/entry/calling.h +7 -0

index 9a9e588..bf397426 100644
@@ -201,6 +201,23 @@ For 32-bit we have the following conventions - kernel is built with
        .byte 0xf1
        .endm
 
+       /*
+        * This is a sneaky trick to help the unwinder find pt_regs on the
+        * stack.  The frame pointer is replaced with an encoded pointer to
+        * pt_regs.  The encoding is just a clearing of the highest-order bit,
+        * which makes it an invalid address and is also a signal to the
+        * unwinder that it's a pt_regs pointer in disguise.
+        *

Andy,

So I got a chance to look at this some more. I'm thinking that to make this feature more consistently useful, we shouldn't only annotate pt_regs frames for calls to handlers; other calls should be annotated as
well: preempt_schedule_irq, CALL_enter_from_user_mode, prepare_exit_to_usermode, SWAPGS, TRACE_IRQS_OFF, DISABLE_INTERRUPTS, etc. That way, the unwinder will always be able to find pt_regs from an interrupt/exception, even if starting from one of these other calls.

But then, things get ugly. You have to either setup and tear down the frame for every possible call, or do a higher-level setup/teardown across multiple calls, which invalidates several assumptions in the entry code about the location of pt_regs on the stack.

Quoted 10 lines · Josh Poimboeuf

Andy,

So I got a chance to look at this some more. I'm thinking that to make this feature more consistently useful, we shouldn't only annotate pt_regs frames for calls to handlers; other calls should be annotated as
well: preempt_schedule_irq, CALL_enter_from_user_mode, prepare_exit_to_usermode, SWAPGS, TRACE_IRQS_OFF, DISABLE_INTERRUPTS, etc. That way, the unwinder will always be able to find pt_regs from an interrupt/exception, even if starting from one of these other calls.

Quoted 5 lines

But then, things get ugly. You have to either setup and tear down the frame for every possible call, or do a higher-level setup/teardown across multiple calls, which invalidates several assumptions in the entry code about the location of pt_regs on the stack.

Here's yet another harebrained idea. Maybe it works better than my previous harebrained ideas :)

Your patch is already creating a somewhat nonstandard stack frame:

arch/x86/entry/calling.h +3 -0

+       movq    %rbp,                   0*8(%rsp)
+       movq    $entry_frame_ret,       1*8(%rsp)
+       movq    %rsp, %rbp

It's kind of a normal stack frame, but rbp points at something odd, and to unwind it fully correctly, the unwinder needs to know about it.

What if we made it even more special, along the lines of:

leaq offset_to_ptregs(%rsp), %rbp
xorq $-1, %rbp

IOW, don't write anything to the stack at all, and just put a special value into RBP that says "the next frame is pt_regs at such-and-such address". Do this once on entry and make sure to restore RBP (from pt_regs) on exit. Now the unwinder can notice that RBP has the high bits clear *and* that the negation of it points to the stack, and it can figure out what's going on.

What do you think? Am I nuts or could this work?

It had better not have much risk of breaking things worse than they currently are, given that current kernel allow user code to stick any value it likes into the very last element of the RBP chain.

In preparation for being able to determine whether a given stack trace is reliable, allow the stacktrace_ops functions to propagate errors to dump_trace().

Quoted 3 lines · Josh Poimboeuf

In preparation for being able to determine whether a given stack trace is reliable, allow the stacktrace_ops functions to propagate errors to dump_trace().

Hi, Josh.

Have you considered to make walk_stack function as non-return function, since there is no obvious error during detecting the frame points?