Provide functions which handle the low level entry and exit similiar to
enter/exit from user mode.
Signed-off-by: Thomas Gleixner <[email protected]>
---
arch/x86/entry/common.c | 89 ++++++++++++++++++++++++++++++++++++++++
arch/x86/include/asm/idtentry.h | 3 +
2 files changed, 92 insertions(+)
--- a/arch/x86/entry/common.c
+++ b/arch/x86/entry/common.c
@@ -510,3 +510,92 @@ SYSCALL_DEFINE0(ni_syscall)
{
return -ENOSYS;
}
+
+/**
+ * idtentry_enter - Handle state tracking on idtentry
+ * @regs: Pointer to pt_regs of interrupted context
+ *
+ * Invokes:
+ * - lockdep irqflag state tracking as low level ASM entry disabled
+ * interrupts.
+ *
+ * - Context tracking if the exception hit user mode.
+ *
+ * - RCU notification if the exception hit kernel mode
+ *
+ * - The hardirq tracer to keep the state consistent as low level ASM
+ * entry disabled interrupts.
+ */
+void noinstr idtentry_enter(struct pt_regs *regs)
+{
+ if (user_mode(regs)) {
+ enter_from_user_mode();
+ } else {
+ lockdep_hardirqs_off(CALLER_ADDR0);
+ rcu_irq_enter();
+ instr_begin();
+ trace_hardirqs_off_prepare();
+ instr_end();
+ }
+}
+
+/**
+ * idtentry_exit - Common code to handle return from exceptions
+ * @regs: Pointer to pt_regs (exception entry regs)
+ *
+ * Depending on the return target (kernel/user) this runs the necessary
+ * preemption and work checks if possible and reguired and returns to
+ * the caller with interrupts disabled and no further work pending.
+ *
+ * This is the last action before returning to the low level ASM code which
+ * just needs to return to the appropriate context.
+ *
+ * Invoked by all exception/interrupt IDTENTRY handlers which are not
+ * returning through the paranoid exit path (all except NMI, #DF and the IST
+ * variants of #MC and #DB).
+ */
+void noinstr idtentry_exit(struct pt_regs *regs)
+{
+ lockdep_assert_irqs_disabled();
+
+ /* Check whether this returns to user mode */
+ if (user_mode(regs)) {
+ prepare_exit_to_usermode(regs);
+ } else if (regs->flags & X86_EFLAGS_IF) {
+ /* Check kernel preemption, if enabled */
+ if (IS_ENABLED(CONFIG_PREEMPTION)) {
+ /*
+ * This needs to be done very carefully.
+ * idtentry_enter() invoked rcu_irq_enter(). This
+ * needs to undone before scheduling.
+ *
+ * Preemption is disabled inside of RCU idle
+ * sections. When the task returns from
+ * preempt_schedule_irq(), RCU is still watching.
+ *
+ * rcu_irq_exit_preempt() has additional state
+ * checking if CONFIG_PROVE_RCU=y
+ */
+ if (!preempt_count()) {
+ instr_begin();
+ rcu_irq_exit_preempt();
+ if (need_resched())
+ preempt_schedule_irq();
+ /* Covers both tracing and lockdep */
+ trace_hardirqs_on();
+ instr_end();
+ return;
+ }
+ }
+ instr_begin();
+ /* Tell the tracer that IRET will enable interrupts */
+ trace_hardirqs_on_prepare();
+ lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+ instr_end();
+ rcu_irq_exit();
+ lockdep_hardirqs_on(CALLER_ADDR0);
+ } else {
+ /* IRQ flags state is correct already. Just tell RCU */
+ rcu_irq_exit();
+ }
+}
--- a/arch/x86/include/asm/idtentry.h
+++ b/arch/x86/include/asm/idtentry.h
@@ -7,6 +7,9 @@
#ifndef __ASSEMBLY__
+void idtentry_enter(struct pt_regs *regs);
+void idtentry_exit(struct pt_regs *regs);
+
/**
* DECLARE_IDTENTRY - Declare functions for simple IDT entry points
* No error code pushed by hardware
On 5/5/20 3:44 PM, Thomas Gleixner wrote:
> Provide functions which handle the low level entry and exit similiar to
> enter/exit from user mode.
typo: "similiar"
> Signed-off-by: Thomas Gleixner <[email protected]>
> ---
> arch/x86/entry/common.c | 89 ++++++++++++++++++++++++++++++++++++++++
> arch/x86/include/asm/idtentry.h | 3 +
> 2 files changed, 92 insertions(+)
>
> --- a/arch/x86/entry/common.c
> +++ b/arch/x86/entry/common.c
...
> +/**
> + * idtentry_exit - Common code to handle return from exceptions
> + * @regs: Pointer to pt_regs (exception entry regs)
> + *
> + * Depending on the return target (kernel/user) this runs the necessary
> + * preemption and work checks if possible and reguired and returns to
typo: "reguired"
alex.
On Tue, May 5, 2020 at 7:15 AM Thomas Gleixner <[email protected]> wrote:
>
> Provide functions which handle the low level entry and exit similiar to
> enter/exit from user mode.
>
> +
> +/**
> + * idtentry_exit - Common code to handle return from exceptions
> + * @regs: Pointer to pt_regs (exception entry regs)
> + *
> + * Depending on the return target (kernel/user) this runs the necessary
> + * preemption and work checks if possible and reguired and returns to
> + * the caller with interrupts disabled and no further work pending.
> + *
> + * This is the last action before returning to the low level ASM code which
> + * just needs to return to the appropriate context.
> + *
> + * Invoked by all exception/interrupt IDTENTRY handlers which are not
> + * returning through the paranoid exit path (all except NMI, #DF and the IST
> + * variants of #MC and #DB).
The paranoid-exit bit is not really relevant. The important part is
which stack we're on. See below.
> + */
> +void noinstr idtentry_exit(struct pt_regs *regs)
> +{
> + lockdep_assert_irqs_disabled();
How about:
#ifdef CONFIG_DEBUG_ENTRY
WARN_ON_ONCE(!on_thread_stack());
#endif
> +
> + /* Check whether this returns to user mode */
> + if (user_mode(regs)) {
> + prepare_exit_to_usermode(regs);
> + } else if (regs->flags & X86_EFLAGS_IF) {
> + /* Check kernel preemption, if enabled */
> + if (IS_ENABLED(CONFIG_PREEMPTION)) {
> + /*
> + * This needs to be done very carefully.
> + * idtentry_enter() invoked rcu_irq_enter(). This
> + * needs to undone before scheduling.
> + *
> + * Preemption is disabled inside of RCU idle
> + * sections. When the task returns from
> + * preempt_schedule_irq(), RCU is still watching.
> + *
> + * rcu_irq_exit_preempt() has additional state
> + * checking if CONFIG_PROVE_RCU=y
> + */
> + if (!preempt_count()) {
> + instr_begin();
> + rcu_irq_exit_preempt();
> + if (need_resched())
> + preempt_schedule_irq();
This is an excellent improvement. Thanks!
> + /* Covers both tracing and lockdep */
> + trace_hardirqs_on();
> + instr_end();
> + return;
> + }
> + }
> + instr_begin();
> + /* Tell the tracer that IRET will enable interrupts */
> + trace_hardirqs_on_prepare();
Why is trace_hardirqs_on() okay above but not here? Is it that we
know we weren't RCU-quiescent if we had preemption and IF on? But
even this code path came from an IF-on context. I'm confused. Maybe
some comments as to why this case seems to be ordered so differently
from the !preempt_count() case would be helpful.
> + lockdep_hardirqs_on_prepare(CALLER_ADDR0);
> + instr_end();
> + rcu_irq_exit();
> + lockdep_hardirqs_on(CALLER_ADDR0);
> + } else {
> + /* IRQ flags state is correct already. Just tell RCU */
> + rcu_irq_exit();
> + }
> +}
> --- a/arch/x86/include/asm/idtentry.h
> +++ b/arch/x86/include/asm/idtentry.h
> @@ -7,6 +7,9 @@
>
> #ifndef __ASSEMBLY__
>
> +void idtentry_enter(struct pt_regs *regs);
> +void idtentry_exit(struct pt_regs *regs);
> +
> /**
> * DECLARE_IDTENTRY - Declare functions for simple IDT entry points
> * No error code pushed by hardware
>
Andy Lutomirski <[email protected]> writes:
>> + * Invoked by all exception/interrupt IDTENTRY handlers which are not
>> + * returning through the paranoid exit path (all except NMI, #DF and the IST
>> + * variants of #MC and #DB).
>
> The paranoid-exit bit is not really relevant. The important part is
> which stack we're on. See below.
Right. I amended the comment to that effect.
>> + */
>> +void noinstr idtentry_exit(struct pt_regs *regs)
>> +{
>> + lockdep_assert_irqs_disabled();
>
> How about:
>
> #ifdef CONFIG_DEBUG_ENTRY
> WARN_ON_ONCE(!on_thread_stack());
> #endif
Made this if (IS_ENABLED()) ..
>> + instr_begin();
>> + /* Tell the tracer that IRET will enable interrupts */
>> + trace_hardirqs_on_prepare();
>
> Why is trace_hardirqs_on() okay above but not here? Is it that we
> know we weren't RCU-quiescent if we had preemption and IF on? But
> even this code path came from an IF-on context. I'm confused. Maybe
> some comments as to why this case seems to be ordered so differently
> from the !preempt_count() case would be helpful.
Added commentry. Updated patch below.
Thanks,
tglx
8<-----------------
Subject: x86/entry/common: Provide idtentry_enter/exit()
From: Thomas Gleixner <[email protected]>
Date: Thu, 26 Mar 2020 16:28:52 +0100
Provide functions which handle the low level entry and exit similar to
enter/exit from user mode.
Signed-off-by: Thomas Gleixner <[email protected]>
---
arch/x86/entry/common.c | 100 ++++++++++++++++++++++++++++++++++++++++
arch/x86/include/asm/idtentry.h | 3 +
2 files changed, 103 insertions(+)
--- a/arch/x86/entry/common.c
+++ b/arch/x86/entry/common.c
@@ -510,3 +510,103 @@ SYSCALL_DEFINE0(ni_syscall)
{
return -ENOSYS;
}
+
+/**
+ * idtentry_enter - Handle state tracking on idtentry
+ * @regs: Pointer to pt_regs of interrupted context
+ *
+ * Invokes:
+ * - lockdep irqflag state tracking as low level ASM entry disabled
+ * interrupts.
+ *
+ * - Context tracking if the exception hit user mode.
+ *
+ * - RCU notification if the exception hit kernel mode
+ *
+ * - The hardirq tracer to keep the state consistent as low level ASM
+ * entry disabled interrupts.
+ */
+void noinstr idtentry_enter(struct pt_regs *regs)
+{
+ if (user_mode(regs)) {
+ enter_from_user_mode();
+ } else {
+ lockdep_hardirqs_off(CALLER_ADDR0);
+ rcu_irq_enter();
+ instrumentation_begin();
+ trace_hardirqs_off_prepare();
+ instrumentation_end();
+ }
+}
+
+/**
+ * idtentry_exit - Common code to handle return from exceptions
+ * @regs: Pointer to pt_regs (exception entry regs)
+ *
+ * Depending on the return target (kernel/user) this runs the necessary
+ * preemption and work checks if possible and required and returns to
+ * the caller with interrupts disabled and no further work pending.
+ *
+ * This is the last action before returning to the low level ASM code which
+ * just needs to return to the appropriate context.
+ *
+ * Invoked by all exception/interrupt IDTENTRY handlers which are not
+ * returning through the paranoid exit path (all except NMI, #DF and the IST
+ * variants of #MC and #DB) and are therefore on the thread stack.
+ */
+void noinstr idtentry_exit(struct pt_regs *regs)
+{
+ lockdep_assert_irqs_disabled();
+
+ if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
+ WARN_ON_ONCE(!on_thread_stack());
+
+ /* Check whether this returns to user mode */
+ if (user_mode(regs)) {
+ prepare_exit_to_usermode(regs);
+ } else if (regs->flags & X86_EFLAGS_IF) {
+ /* Check kernel preemption, if enabled */
+ if (IS_ENABLED(CONFIG_PREEMPTION)) {
+ /*
+ * This needs to be done very carefully.
+ * idtentry_enter() invoked rcu_irq_enter(). This
+ * needs to undone before scheduling.
+ *
+ * Preemption is disabled inside of RCU idle
+ * sections. When the task returns from
+ * preempt_schedule_irq(), RCU is still watching.
+ *
+ * rcu_irq_exit_preempt() has additional state
+ * checking if CONFIG_PROVE_RCU=y
+ */
+ if (!preempt_count()) {
+ instrumentation_begin();
+ rcu_irq_exit_preempt();
+ if (need_resched())
+ preempt_schedule_irq();
+ /* Covers both tracing and lockdep */
+ trace_hardirqs_on();
+ instrumentation_end();
+ return;
+ }
+ }
+ /*
+ * If preemption is disabled then this needs to be done
+ * carefully with respect to RCU. The exception might come
+ * from a RCU idle section in the idle task due to the fact
+ * that safe_halt() enables interrupts. So this needs the
+ * same ordering of lockdep/tracing and RCU as the return
+ * to user mode path.
+ */
+ instrumentation_begin();
+ /* Tell the tracer that IRET will enable interrupts */
+ trace_hardirqs_on_prepare();
+ lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+ instrumentation_end();
+ rcu_irq_exit();
+ lockdep_hardirqs_on(CALLER_ADDR0);
+ } else {
+ /* IRQ flags state is correct already. Just tell RCU */
+ rcu_irq_exit();
+ }
+}
--- a/arch/x86/include/asm/idtentry.h
+++ b/arch/x86/include/asm/idtentry.h
@@ -7,6 +7,9 @@
#ifndef __ASSEMBLY__
+void idtentry_enter(struct pt_regs *regs);
+void idtentry_exit(struct pt_regs *regs);
+
/**
* DECLARE_IDTENTRY - Declare functions for simple IDT entry points
* No error code pushed by hardware
On Mon, May 11, 2020 at 3:59 AM Thomas Gleixner <[email protected]> wrote:
>
> Andy Lutomirski <[email protected]> writes:
> >> + * Invoked by all exception/interrupt IDTENTRY handlers which are not
> >> + * returning through the paranoid exit path (all except NMI, #DF and the IST
> >> + * variants of #MC and #DB).
> >
> +void noinstr idtentry_exit(struct pt_regs *regs)
> +{
> + lockdep_assert_irqs_disabled();
> +
> + if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
> + WARN_ON_ONCE(!on_thread_stack());
Whoops. After sleeping on this, this is obviously wrong. If this is
something like a page fault, we can be on an IST or IRQ stack.
Perhaps the actual condition should be:
WARN_ON_ONCE(!on_thread_stack() && (regs->flags & X86_FLAGS_IF) &&
preempt_count() == 0);
IOW, the actual condition we want is that, if the idtenter_entry/exit
code might schedule or if a cond_local_irq_enable() path might
schedule, we had better be on the correct stack.
Sorry for causing confusion.
Andy Lutomirski <[email protected]> writes:
> On Mon, May 11, 2020 at 3:59 AM Thomas Gleixner <[email protected]> wrote:
>>
>> Andy Lutomirski <[email protected]> writes:
>> >> + * Invoked by all exception/interrupt IDTENTRY handlers which are not
>> >> + * returning through the paranoid exit path (all except NMI, #DF and the IST
>> >> + * variants of #MC and #DB).
>> >
>
>> +void noinstr idtentry_exit(struct pt_regs *regs)
>> +{
>> + lockdep_assert_irqs_disabled();
>> +
>> + if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
>> + WARN_ON_ONCE(!on_thread_stack());
>
> Whoops. After sleeping on this, this is obviously wrong. If this is
> something like a page fault, we can be on an IST or IRQ stack.
> Perhaps the actual condition should be:
>
> WARN_ON_ONCE(!on_thread_stack() && (regs->flags & X86_FLAGS_IF) &&
> preempt_count() == 0);
>
> IOW, the actual condition we want is that, if the idtenter_entry/exit
> code might schedule or if a cond_local_irq_enable() path might
> schedule, we had better be on the correct stack.
>
> Sorry for causing confusion.
Nothing to be sorry about. I could have thought about it myself :)
Let me try again.
Thomas Gleixner <[email protected]> writes:
> Andy Lutomirski <[email protected]> writes:
>> WARN_ON_ONCE(!on_thread_stack() && (regs->flags & X86_FLAGS_IF) &&
>> preempt_count() == 0);
>>
>> IOW, the actual condition we want is that, if the idtenter_entry/exit
>> code might schedule or if a cond_local_irq_enable() path might
>> schedule, we had better be on the correct stack.
>>
>> Sorry for causing confusion.
>
> Nothing to be sorry about. I could have thought about it myself :)
> Let me try again.
Move it into the actual preemption condition. Most natural place.
Thanks,
tglx
8<--------------------
Subject: x86/entry/common: Provide idtentry_enter/exit()
From: Thomas Gleixner <[email protected]>
Date: Thu, 26 Mar 2020 16:28:52 +0100
Provide functions which handle the low level entry and exit similar to
enter/exit from user mode.
Signed-off-by: Thomas Gleixner <[email protected]>
Reviewed-by: Alexandre Chartre <[email protected]>
Acked-by: Peter Zijlstra <[email protected]>
Link: https://lkml.kernel.org/r/[email protected]
---
arch/x86/entry/common.c | 99 ++++++++++++++++++++++++++++++++++++++++
arch/x86/include/asm/idtentry.h | 3 +
2 files changed, 102 insertions(+)
--- a/arch/x86/entry/common.c
+++ b/arch/x86/entry/common.c
@@ -510,3 +510,102 @@ SYSCALL_DEFINE0(ni_syscall)
{
return -ENOSYS;
}
+
+/**
+ * idtentry_enter - Handle state tracking on idtentry
+ * @regs: Pointer to pt_regs of interrupted context
+ *
+ * Invokes:
+ * - lockdep irqflag state tracking as low level ASM entry disabled
+ * interrupts.
+ *
+ * - Context tracking if the exception hit user mode.
+ *
+ * - RCU notification if the exception hit kernel mode
+ *
+ * - The hardirq tracer to keep the state consistent as low level ASM
+ * entry disabled interrupts.
+ */
+void noinstr idtentry_enter(struct pt_regs *regs)
+{
+ if (user_mode(regs)) {
+ enter_from_user_mode();
+ } else {
+ lockdep_hardirqs_off(CALLER_ADDR0);
+ rcu_irq_enter();
+ instrumentation_begin();
+ trace_hardirqs_off_prepare();
+ instrumentation_end();
+ }
+}
+
+/**
+ * idtentry_exit - Common code to handle return from exceptions
+ * @regs: Pointer to pt_regs (exception entry regs)
+ *
+ * Depending on the return target (kernel/user) this runs the necessary
+ * preemption and work checks if possible and required and returns to
+ * the caller with interrupts disabled and no further work pending.
+ *
+ * This is the last action before returning to the low level ASM code which
+ * just needs to return to the appropriate context.
+ *
+ * Invoked by all exception/interrupt IDTENTRY handlers which are not
+ * returning through the paranoid exit path (all except NMI, #DF and the IST
+ * variants of #MC and #DB) and are therefore on the thread stack.
+ */
+void noinstr idtentry_exit(struct pt_regs *regs)
+{
+ lockdep_assert_irqs_disabled();
+
+ /* Check whether this returns to user mode */
+ if (user_mode(regs)) {
+ prepare_exit_to_usermode(regs);
+ } else if (regs->flags & X86_EFLAGS_IF) {
+ /* Check kernel preemption, if enabled */
+ if (IS_ENABLED(CONFIG_PREEMPTION)) {
+ /*
+ * This needs to be done very carefully.
+ * idtentry_enter() invoked rcu_irq_enter(). This
+ * needs to undone before scheduling.
+ *
+ * Preemption is disabled inside of RCU idle
+ * sections. When the task returns from
+ * preempt_schedule_irq(), RCU is still watching.
+ *
+ * rcu_irq_exit_preempt() has additional state
+ * checking if CONFIG_PROVE_RCU=y
+ */
+ if (!preempt_count()) {
+ if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
+ WARN_ON_ONCE(!on_thread_stack());
+ instrumentation_begin();
+ rcu_irq_exit_preempt();
+ if (need_resched())
+ preempt_schedule_irq();
+ /* Covers both tracing and lockdep */
+ trace_hardirqs_on();
+ instrumentation_end();
+ return;
+ }
+ }
+ /*
+ * If preemption is disabled then this needs to be done
+ * carefully with respect to RCU. The exception might come
+ * from a RCU idle section in the idle task due to the fact
+ * that safe_halt() enables interrupts. So this needs the
+ * same ordering of lockdep/tracing and RCU as the return
+ * to user mode path.
+ */
+ instrumentation_begin();
+ /* Tell the tracer that IRET will enable interrupts */
+ trace_hardirqs_on_prepare();
+ lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+ instrumentation_end();
+ rcu_irq_exit();
+ lockdep_hardirqs_on(CALLER_ADDR0);
+ } else {
+ /* IRQ flags state is correct already. Just tell RCU */
+ rcu_irq_exit();
+ }
+}
--- a/arch/x86/include/asm/idtentry.h
+++ b/arch/x86/include/asm/idtentry.h
@@ -7,6 +7,9 @@
#ifndef __ASSEMBLY__
+void idtentry_enter(struct pt_regs *regs);
+void idtentry_exit(struct pt_regs *regs);
+
/**
* DECLARE_IDTENTRY - Declare functions for simple IDT entry points
* No error code pushed by hardware
On Tue, May 12, 2020 at 9:50 AM Thomas Gleixner <[email protected]> wrote:
>
> Thomas Gleixner <[email protected]> writes:
> > Andy Lutomirski <[email protected]> writes:
> >> WARN_ON_ONCE(!on_thread_stack() && (regs->flags & X86_FLAGS_IF) &&
> >> preempt_count() == 0);
> >>
> >> IOW, the actual condition we want is that, if the idtenter_entry/exit
> >> code might schedule or if a cond_local_irq_enable() path might
> >> schedule, we had better be on the correct stack.
> >>
> >> Sorry for causing confusion.
> >
> > Nothing to be sorry about. I could have thought about it myself :)
> > Let me try again.
>
> Move it into the actual preemption condition. Most natural place.
Nice! This way the logic is clear and the warning will fire even if
no actual preemption occurs.
Acked-by: Andy Lutomirski <[email protected]>
----- On May 5, 2020, at 9:44 AM, Thomas Gleixner [email protected] wrote:
[...]
> + * Invokes:
> + * - lockdep irqflag state tracking as low level ASM entry disabled
> + * interrupts.
> + *
> + * - Context tracking if the exception hit user mode.
> + *
> + * - RCU notification if the exception hit kernel mode
Nit: missing "." at end of line.
> + *
> + * - The hardirq tracer to keep the state consistent as low level ASM
> + * entry disabled interrupts.
> + * This needs to be done very carefully.
> + * idtentry_enter() invoked rcu_irq_enter(). This
> + * needs to undone before scheduling.
Nit: "to undone" -> "to be undone".
Thanks,
Mathieu
--
Mathieu Desnoyers
EfficiOS Inc.
http://www.efficios.com
The following commit has been merged into the x86/entry branch of tip:
Commit-ID: eadb831607477ba774b3314bdc956331b41817d6
Gitweb: https://git.kernel.org/tip/eadb831607477ba774b3314bdc956331b41817d6
Author: Thomas Gleixner <[email protected]>
AuthorDate: Thu, 26 Mar 2020 16:28:52 +01:00
Committer: Thomas Gleixner <[email protected]>
CommitterDate: Tue, 19 May 2020 16:03:57 +02:00
x86/entry/common: Provide idtentry_enter/exit()
Provide functions which handle the low level entry and exit similar to
enter/exit from user mode.
Signed-off-by: Thomas Gleixner <[email protected]>
Reviewed-by: Alexandre Chartre <[email protected]>
Acked-by: Peter Zijlstra <[email protected]>
Acked-by: Andy Lutomirski <[email protected]>
Link: https://lkml.kernel.org/r/[email protected]
---
arch/x86/entry/common.c | 99 +++++++++++++++++++++++++++++++-
arch/x86/include/asm/idtentry.h | 3 +-
2 files changed, 102 insertions(+)
diff --git a/arch/x86/entry/common.c b/arch/x86/entry/common.c
index e4f9f5f..9ebe334 100644
--- a/arch/x86/entry/common.c
+++ b/arch/x86/entry/common.c
@@ -510,3 +510,102 @@ SYSCALL_DEFINE0(ni_syscall)
{
return -ENOSYS;
}
+
+/**
+ * idtentry_enter - Handle state tracking on idtentry
+ * @regs: Pointer to pt_regs of interrupted context
+ *
+ * Invokes:
+ * - lockdep irqflag state tracking as low level ASM entry disabled
+ * interrupts.
+ *
+ * - Context tracking if the exception hit user mode.
+ *
+ * - RCU notification if the exception hit kernel mode.
+ *
+ * - The hardirq tracer to keep the state consistent as low level ASM
+ * entry disabled interrupts.
+ */
+void noinstr idtentry_enter(struct pt_regs *regs)
+{
+ if (user_mode(regs)) {
+ enter_from_user_mode();
+ } else {
+ lockdep_hardirqs_off(CALLER_ADDR0);
+ rcu_irq_enter();
+ instrumentation_begin();
+ trace_hardirqs_off_prepare();
+ instrumentation_end();
+ }
+}
+
+/**
+ * idtentry_exit - Common code to handle return from exceptions
+ * @regs: Pointer to pt_regs (exception entry regs)
+ *
+ * Depending on the return target (kernel/user) this runs the necessary
+ * preemption and work checks if possible and required and returns to
+ * the caller with interrupts disabled and no further work pending.
+ *
+ * This is the last action before returning to the low level ASM code which
+ * just needs to return to the appropriate context.
+ *
+ * Invoked by all exception/interrupt IDTENTRY handlers which are not
+ * returning through the paranoid exit path (all except NMI, #DF and the IST
+ * variants of #MC and #DB) and are therefore on the thread stack.
+ */
+void noinstr idtentry_exit(struct pt_regs *regs)
+{
+ lockdep_assert_irqs_disabled();
+
+ /* Check whether this returns to user mode */
+ if (user_mode(regs)) {
+ prepare_exit_to_usermode(regs);
+ } else if (regs->flags & X86_EFLAGS_IF) {
+ /* Check kernel preemption, if enabled */
+ if (IS_ENABLED(CONFIG_PREEMPTION)) {
+ /*
+ * This needs to be done very carefully.
+ * idtentry_enter() invoked rcu_irq_enter(). This
+ * needs to be undone before scheduling.
+ *
+ * Preemption is disabled inside of RCU idle
+ * sections. When the task returns from
+ * preempt_schedule_irq(), RCU is still watching.
+ *
+ * rcu_irq_exit_preempt() has additional state
+ * checking if CONFIG_PROVE_RCU=y
+ */
+ if (!preempt_count()) {
+ if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
+ WARN_ON_ONCE(!on_thread_stack());
+ instrumentation_begin();
+ rcu_irq_exit_preempt();
+ if (need_resched())
+ preempt_schedule_irq();
+ /* Covers both tracing and lockdep */
+ trace_hardirqs_on();
+ instrumentation_end();
+ return;
+ }
+ }
+ /*
+ * If preemption is disabled then this needs to be done
+ * carefully with respect to RCU. The exception might come
+ * from a RCU idle section in the idle task due to the fact
+ * that safe_halt() enables interrupts. So this needs the
+ * same ordering of lockdep/tracing and RCU as the return
+ * to user mode path.
+ */
+ instrumentation_begin();
+ /* Tell the tracer that IRET will enable interrupts */
+ trace_hardirqs_on_prepare();
+ lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+ instrumentation_end();
+ rcu_irq_exit();
+ lockdep_hardirqs_on(CALLER_ADDR0);
+ } else {
+ /* IRQ flags state is correct already. Just tell RCU */
+ rcu_irq_exit();
+ }
+}
diff --git a/arch/x86/include/asm/idtentry.h b/arch/x86/include/asm/idtentry.h
index bbd81e2..2adfd80 100644
--- a/arch/x86/include/asm/idtentry.h
+++ b/arch/x86/include/asm/idtentry.h
@@ -7,6 +7,9 @@
#ifndef __ASSEMBLY__
+void idtentry_enter(struct pt_regs *regs);
+void idtentry_exit(struct pt_regs *regs);
+
/**
* DECLARE_IDTENTRY - Declare functions for simple IDT entry points
* No error code pushed by hardware