kernel/context_tracking.c

   1 /*
   2  * Context tracking: Probe on high level context boundaries such as kernel
   3  * and userspace. This includes syscalls and exceptions entry/exit.
   4  *
   5  * This is used by RCU to remove its dependency on the timer tick while a CPU
   6  * runs in userspace.
   7  *
   8  *  Started by Frederic Weisbecker:
   9  *
  10  * Copyright (C) 2012 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
  11  *
  12  * Many thanks to Gilad Ben-Yossef, Paul McKenney, Ingo Molnar, Andrew Morton,
  13  * Steven Rostedt, Peter Zijlstra for suggestions and improvements.
  14  *
  15  */
  16
  17 #include <linux/context_tracking.h>
  18 #include <linux/kvm_host.h>
  19 #include <linux/rcupdate.h>
  20 #include <linux/sched.h>
  21 #include <linux/hardirq.h>
  22 #include <linux/export.h>
  23
  24 DEFINE_PER_CPU(struct context_tracking, context_tracking) = {
  25 #ifdef CONFIG_CONTEXT_TRACKING_FORCE
  26         .active = true,
  27 #endif
  28 };
  29
  30 /**
  31  * user_enter - Inform the context tracking that the CPU is going to
  32  *              enter userspace mode.
  33  *
  34  * This function must be called right before we switch from the kernel
  35  * to userspace, when it's guaranteed the remaining kernel instructions
  36  * to execute won't use any RCU read side critical section because this
  37  * function sets RCU in extended quiescent state.
  38  */
  39 void user_enter(void)
  40 {
  41         unsigned long flags;
  42
  43         /*
  44          * Some contexts may involve an exception occuring in an irq,
  45          * leading to that nesting:
  46          * rcu_irq_enter() rcu_user_exit() rcu_user_exit() rcu_irq_exit()
  47          * This would mess up the dyntick_nesting count though. And rcu_irq_*()
  48          * helpers are enough to protect RCU uses inside the exception. So
  49          * just return immediately if we detect we are in an IRQ.
  50          */
  51         if (in_interrupt())
  52                 return;
  53
  54         /* Kernel threads aren't supposed to go to userspace */
  55         WARN_ON_ONCE(!current->mm);
  56
  57         local_irq_save(flags);
  58         if (__this_cpu_read(context_tracking.active) &&
  59             __this_cpu_read(context_tracking.state) != IN_USER) {
  60                 /*
  61                  * At this stage, only low level arch entry code remains and
  62                  * then we'll run in userspace. We can assume there won't be
  63                  * any RCU read-side critical section until the next call to
  64                  * user_exit() or rcu_irq_enter(). Let's remove RCU's dependency
  65                  * on the tick.
  66                  */
  67                 vtime_user_enter(current);
  68                 rcu_user_enter();
  69                 __this_cpu_write(context_tracking.state, IN_USER);
  70         }
  71         local_irq_restore(flags);
  72 }
  73
  74 #ifdef CONFIG_PREEMPT
  75 /**
  76  * preempt_schedule_context - preempt_schedule called by tracing
  77  *
  78  * The tracing infrastructure uses preempt_enable_notrace to prevent
  79  * recursion and tracing preempt enabling caused by the tracing
  80  * infrastructure itself. But as tracing can happen in areas coming
  81  * from userspace or just about to enter userspace, a preempt enable
  82  * can occur before user_exit() is called. This will cause the scheduler
  83  * to be called when the system is still in usermode.
  84  *
  85  * To prevent this, the preempt_enable_notrace will use this function
  86  * instead of preempt_schedule() to exit user context if needed before
  87  * calling the scheduler.
  88  */
  89 void __sched notrace preempt_schedule_context(void)
  90 {
  91         struct thread_info *ti = current_thread_info();
  92         enum ctx_state prev_ctx;
  93
  94         if (likely(ti->preempt_count || irqs_disabled()))
  95                 return;
  96
  97         /*
  98          * Need to disable preemption in case user_exit() is traced
  99          * and the tracer calls preempt_enable_notrace() causing
 100          * an infinite recursion.
 101          */
 102         preempt_disable_notrace();
 103         prev_ctx = exception_enter();
 104         preempt_enable_no_resched_notrace();
 105
 106         preempt_schedule();
 107
 108         preempt_disable_notrace();
 109         exception_exit(prev_ctx);
 110         preempt_enable_notrace();
 111 }
 112 EXPORT_SYMBOL_GPL(preempt_schedule_context);
 113 #endif /* CONFIG_PREEMPT */
 114
 115 /**
 116  * user_exit - Inform the context tracking that the CPU is
 117  *             exiting userspace mode and entering the kernel.
 118  *
 119  * This function must be called after we entered the kernel from userspace
 120  * before any use of RCU read side critical section. This potentially include
 121  * any high level kernel code like syscalls, exceptions, signal handling, etc...
 122  *
 123  * This call supports re-entrancy. This way it can be called from any exception
 124  * handler without needing to know if we came from userspace or not.
 125  */
 126 void user_exit(void)
 127 {
 128         unsigned long flags;
 129
 130         if (in_interrupt())
 131                 return;
 132
 133         local_irq_save(flags);
 134         if (__this_cpu_read(context_tracking.state) == IN_USER) {
 135                 /*
 136                  * We are going to run code that may use RCU. Inform
 137                  * RCU core about that (ie: we may need the tick again).
 138                  */
 139                 rcu_user_exit();
 140                 vtime_user_exit(current);
 141                 __this_cpu_write(context_tracking.state, IN_KERNEL);
 142         }
 143         local_irq_restore(flags);
 144 }
 145
 146 void guest_enter(void)
 147 {
 148         if (vtime_accounting_enabled())
 149                 vtime_guest_enter(current);
 150         else
 151                 __guest_enter();
 152 }
 153 EXPORT_SYMBOL_GPL(guest_enter);
 154
 155 void guest_exit(void)
 156 {
 157         if (vtime_accounting_enabled())
 158                 vtime_guest_exit(current);
 159         else
 160                 __guest_exit();
 161 }
 162 EXPORT_SYMBOL_GPL(guest_exit);
 163
 164
 165 /**
 166  * context_tracking_task_switch - context switch the syscall callbacks
 167  * @prev: the task that is being switched out
 168  * @next: the task that is being switched in
 169  *
 170  * The context tracking uses the syscall slow path to implement its user-kernel
 171  * boundaries probes on syscalls. This way it doesn't impact the syscall fast
 172  * path on CPUs that don't do context tracking.
 173  *
 174  * But we need to clear the flag on the previous task because it may later
 175  * migrate to some CPU that doesn't do the context tracking. As such the TIF
 176  * flag may not be desired there.
 177  */
 178 void context_tracking_task_switch(struct task_struct *prev,
 179                              struct task_struct *next)
 180 {
 181         if (__this_cpu_read(context_tracking.active)) {
 182                 clear_tsk_thread_flag(prev, TIF_NOHZ);
 183                 set_tsk_thread_flag(next, TIF_NOHZ);
 184         }
 185 }