Merge branch 'for-6.1/nvdimm' into libnvdimm-for-next
[platform/kernel/linux-starfive.git] / kernel / context_tracking.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Context tracking: Probe on high level context boundaries such as kernel,
4  * userspace, guest or idle.
5  *
6  * This is used by RCU to remove its dependency on the timer tick while a CPU
7  * runs in idle, userspace or guest mode.
8  *
9  * User/guest tracking started by Frederic Weisbecker:
10  *
11  * Copyright (C) 2012 Red Hat, Inc., Frederic Weisbecker
12  *
13  * Many thanks to Gilad Ben-Yossef, Paul McKenney, Ingo Molnar, Andrew Morton,
14  * Steven Rostedt, Peter Zijlstra for suggestions and improvements.
15  *
16  * RCU extended quiescent state bits imported from kernel/rcu/tree.c
17  * where the relevant authorship may be found.
18  */
19
20 #include <linux/context_tracking.h>
21 #include <linux/rcupdate.h>
22 #include <linux/sched.h>
23 #include <linux/hardirq.h>
24 #include <linux/export.h>
25 #include <linux/kprobes.h>
26 #include <trace/events/rcu.h>
27
28
29 DEFINE_PER_CPU(struct context_tracking, context_tracking) = {
30 #ifdef CONFIG_CONTEXT_TRACKING_IDLE
31         .dynticks_nesting = 1,
32         .dynticks_nmi_nesting = DYNTICK_IRQ_NONIDLE,
33 #endif
34         .state = ATOMIC_INIT(RCU_DYNTICKS_IDX),
35 };
36 EXPORT_SYMBOL_GPL(context_tracking);
37
38 #ifdef CONFIG_CONTEXT_TRACKING_IDLE
39 #define TPS(x)  tracepoint_string(x)
40
41 /* Record the current task on dyntick-idle entry. */
42 static __always_inline void rcu_dynticks_task_enter(void)
43 {
44 #if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL)
45         WRITE_ONCE(current->rcu_tasks_idle_cpu, smp_processor_id());
46 #endif /* #if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL) */
47 }
48
49 /* Record no current task on dyntick-idle exit. */
50 static __always_inline void rcu_dynticks_task_exit(void)
51 {
52 #if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL)
53         WRITE_ONCE(current->rcu_tasks_idle_cpu, -1);
54 #endif /* #if defined(CONFIG_TASKS_RCU) && defined(CONFIG_NO_HZ_FULL) */
55 }
56
57 /* Turn on heavyweight RCU tasks trace readers on idle/user entry. */
58 static __always_inline void rcu_dynticks_task_trace_enter(void)
59 {
60 #ifdef CONFIG_TASKS_TRACE_RCU
61         if (IS_ENABLED(CONFIG_TASKS_TRACE_RCU_READ_MB))
62                 current->trc_reader_special.b.need_mb = true;
63 #endif /* #ifdef CONFIG_TASKS_TRACE_RCU */
64 }
65
66 /* Turn off heavyweight RCU tasks trace readers on idle/user exit. */
67 static __always_inline void rcu_dynticks_task_trace_exit(void)
68 {
69 #ifdef CONFIG_TASKS_TRACE_RCU
70         if (IS_ENABLED(CONFIG_TASKS_TRACE_RCU_READ_MB))
71                 current->trc_reader_special.b.need_mb = false;
72 #endif /* #ifdef CONFIG_TASKS_TRACE_RCU */
73 }
74
75 /*
76  * Record entry into an extended quiescent state.  This is only to be
77  * called when not already in an extended quiescent state, that is,
78  * RCU is watching prior to the call to this function and is no longer
79  * watching upon return.
80  */
81 static noinstr void ct_kernel_exit_state(int offset)
82 {
83         int seq;
84
85         /*
86          * CPUs seeing atomic_add_return() must see prior RCU read-side
87          * critical sections, and we also must force ordering with the
88          * next idle sojourn.
89          */
90         rcu_dynticks_task_trace_enter();  // Before ->dynticks update!
91         seq = ct_state_inc(offset);
92         // RCU is no longer watching.  Better be in extended quiescent state!
93         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && (seq & RCU_DYNTICKS_IDX));
94 }
95
96 /*
97  * Record exit from an extended quiescent state.  This is only to be
98  * called from an extended quiescent state, that is, RCU is not watching
99  * prior to the call to this function and is watching upon return.
100  */
101 static noinstr void ct_kernel_enter_state(int offset)
102 {
103         int seq;
104
105         /*
106          * CPUs seeing atomic_add_return() must see prior idle sojourns,
107          * and we also must force ordering with the next RCU read-side
108          * critical section.
109          */
110         seq = ct_state_inc(offset);
111         // RCU is now watching.  Better not be in an extended quiescent state!
112         rcu_dynticks_task_trace_exit();  // After ->dynticks update!
113         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !(seq & RCU_DYNTICKS_IDX));
114 }
115
116 /*
117  * Enter an RCU extended quiescent state, which can be either the
118  * idle loop or adaptive-tickless usermode execution.
119  *
120  * We crowbar the ->dynticks_nmi_nesting field to zero to allow for
121  * the possibility of usermode upcalls having messed up our count
122  * of interrupt nesting level during the prior busy period.
123  */
124 static void noinstr ct_kernel_exit(bool user, int offset)
125 {
126         struct context_tracking *ct = this_cpu_ptr(&context_tracking);
127
128         WARN_ON_ONCE(ct_dynticks_nmi_nesting() != DYNTICK_IRQ_NONIDLE);
129         WRITE_ONCE(ct->dynticks_nmi_nesting, 0);
130         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
131                      ct_dynticks_nesting() == 0);
132         if (ct_dynticks_nesting() != 1) {
133                 // RCU will still be watching, so just do accounting and leave.
134                 ct->dynticks_nesting--;
135                 return;
136         }
137
138         instrumentation_begin();
139         lockdep_assert_irqs_disabled();
140         trace_rcu_dyntick(TPS("Start"), ct_dynticks_nesting(), 0, ct_dynticks());
141         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !user && !is_idle_task(current));
142         rcu_preempt_deferred_qs(current);
143
144         // instrumentation for the noinstr ct_kernel_exit_state()
145         instrument_atomic_write(&ct->state, sizeof(ct->state));
146
147         instrumentation_end();
148         WRITE_ONCE(ct->dynticks_nesting, 0); /* Avoid irq-access tearing. */
149         // RCU is watching here ...
150         ct_kernel_exit_state(offset);
151         // ... but is no longer watching here.
152         rcu_dynticks_task_enter();
153 }
154
155 /*
156  * Exit an RCU extended quiescent state, which can be either the
157  * idle loop or adaptive-tickless usermode execution.
158  *
159  * We crowbar the ->dynticks_nmi_nesting field to DYNTICK_IRQ_NONIDLE to
160  * allow for the possibility of usermode upcalls messing up our count of
161  * interrupt nesting level during the busy period that is just now starting.
162  */
163 static void noinstr ct_kernel_enter(bool user, int offset)
164 {
165         struct context_tracking *ct = this_cpu_ptr(&context_tracking);
166         long oldval;
167
168         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !raw_irqs_disabled());
169         oldval = ct_dynticks_nesting();
170         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && oldval < 0);
171         if (oldval) {
172                 // RCU was already watching, so just do accounting and leave.
173                 ct->dynticks_nesting++;
174                 return;
175         }
176         rcu_dynticks_task_exit();
177         // RCU is not watching here ...
178         ct_kernel_enter_state(offset);
179         // ... but is watching here.
180         instrumentation_begin();
181
182         // instrumentation for the noinstr ct_kernel_enter_state()
183         instrument_atomic_write(&ct->state, sizeof(ct->state));
184
185         trace_rcu_dyntick(TPS("End"), ct_dynticks_nesting(), 1, ct_dynticks());
186         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !user && !is_idle_task(current));
187         WRITE_ONCE(ct->dynticks_nesting, 1);
188         WARN_ON_ONCE(ct_dynticks_nmi_nesting());
189         WRITE_ONCE(ct->dynticks_nmi_nesting, DYNTICK_IRQ_NONIDLE);
190         instrumentation_end();
191 }
192
193 /**
194  * ct_nmi_exit - inform RCU of exit from NMI context
195  *
196  * If we are returning from the outermost NMI handler that interrupted an
197  * RCU-idle period, update ct->state and ct->dynticks_nmi_nesting
198  * to let the RCU grace-period handling know that the CPU is back to
199  * being RCU-idle.
200  *
201  * If you add or remove a call to ct_nmi_exit(), be sure to test
202  * with CONFIG_RCU_EQS_DEBUG=y.
203  */
204 void noinstr ct_nmi_exit(void)
205 {
206         struct context_tracking *ct = this_cpu_ptr(&context_tracking);
207
208         instrumentation_begin();
209         /*
210          * Check for ->dynticks_nmi_nesting underflow and bad ->dynticks.
211          * (We are exiting an NMI handler, so RCU better be paying attention
212          * to us!)
213          */
214         WARN_ON_ONCE(ct_dynticks_nmi_nesting() <= 0);
215         WARN_ON_ONCE(rcu_dynticks_curr_cpu_in_eqs());
216
217         /*
218          * If the nesting level is not 1, the CPU wasn't RCU-idle, so
219          * leave it in non-RCU-idle state.
220          */
221         if (ct_dynticks_nmi_nesting() != 1) {
222                 trace_rcu_dyntick(TPS("--="), ct_dynticks_nmi_nesting(), ct_dynticks_nmi_nesting() - 2,
223                                   ct_dynticks());
224                 WRITE_ONCE(ct->dynticks_nmi_nesting, /* No store tearing. */
225                            ct_dynticks_nmi_nesting() - 2);
226                 instrumentation_end();
227                 return;
228         }
229
230         /* This NMI interrupted an RCU-idle CPU, restore RCU-idleness. */
231         trace_rcu_dyntick(TPS("Startirq"), ct_dynticks_nmi_nesting(), 0, ct_dynticks());
232         WRITE_ONCE(ct->dynticks_nmi_nesting, 0); /* Avoid store tearing. */
233
234         // instrumentation for the noinstr ct_kernel_exit_state()
235         instrument_atomic_write(&ct->state, sizeof(ct->state));
236         instrumentation_end();
237
238         // RCU is watching here ...
239         ct_kernel_exit_state(RCU_DYNTICKS_IDX);
240         // ... but is no longer watching here.
241
242         if (!in_nmi())
243                 rcu_dynticks_task_enter();
244 }
245
246 /**
247  * ct_nmi_enter - inform RCU of entry to NMI context
248  *
249  * If the CPU was idle from RCU's viewpoint, update ct->state and
250  * ct->dynticks_nmi_nesting to let the RCU grace-period handling know
251  * that the CPU is active.  This implementation permits nested NMIs, as
252  * long as the nesting level does not overflow an int.  (You will probably
253  * run out of stack space first.)
254  *
255  * If you add or remove a call to ct_nmi_enter(), be sure to test
256  * with CONFIG_RCU_EQS_DEBUG=y.
257  */
258 void noinstr ct_nmi_enter(void)
259 {
260         long incby = 2;
261         struct context_tracking *ct = this_cpu_ptr(&context_tracking);
262
263         /* Complain about underflow. */
264         WARN_ON_ONCE(ct_dynticks_nmi_nesting() < 0);
265
266         /*
267          * If idle from RCU viewpoint, atomically increment ->dynticks
268          * to mark non-idle and increment ->dynticks_nmi_nesting by one.
269          * Otherwise, increment ->dynticks_nmi_nesting by two.  This means
270          * if ->dynticks_nmi_nesting is equal to one, we are guaranteed
271          * to be in the outermost NMI handler that interrupted an RCU-idle
272          * period (observation due to Andy Lutomirski).
273          */
274         if (rcu_dynticks_curr_cpu_in_eqs()) {
275
276                 if (!in_nmi())
277                         rcu_dynticks_task_exit();
278
279                 // RCU is not watching here ...
280                 ct_kernel_enter_state(RCU_DYNTICKS_IDX);
281                 // ... but is watching here.
282
283                 instrumentation_begin();
284                 // instrumentation for the noinstr rcu_dynticks_curr_cpu_in_eqs()
285                 instrument_atomic_read(&ct->state, sizeof(ct->state));
286                 // instrumentation for the noinstr ct_kernel_enter_state()
287                 instrument_atomic_write(&ct->state, sizeof(ct->state));
288
289                 incby = 1;
290         } else if (!in_nmi()) {
291                 instrumentation_begin();
292                 rcu_irq_enter_check_tick();
293         } else  {
294                 instrumentation_begin();
295         }
296
297         trace_rcu_dyntick(incby == 1 ? TPS("Endirq") : TPS("++="),
298                           ct_dynticks_nmi_nesting(),
299                           ct_dynticks_nmi_nesting() + incby, ct_dynticks());
300         instrumentation_end();
301         WRITE_ONCE(ct->dynticks_nmi_nesting, /* Prevent store tearing. */
302                    ct_dynticks_nmi_nesting() + incby);
303         barrier();
304 }
305
306 /**
307  * ct_idle_enter - inform RCU that current CPU is entering idle
308  *
309  * Enter idle mode, in other words, -leave- the mode in which RCU
310  * read-side critical sections can occur.  (Though RCU read-side
311  * critical sections can occur in irq handlers in idle, a possibility
312  * handled by irq_enter() and irq_exit().)
313  *
314  * If you add or remove a call to ct_idle_enter(), be sure to test with
315  * CONFIG_RCU_EQS_DEBUG=y.
316  */
317 void noinstr ct_idle_enter(void)
318 {
319         WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && !raw_irqs_disabled());
320         ct_kernel_exit(false, RCU_DYNTICKS_IDX + CONTEXT_IDLE);
321 }
322 EXPORT_SYMBOL_GPL(ct_idle_enter);
323
324 /**
325  * ct_idle_exit - inform RCU that current CPU is leaving idle
326  *
327  * Exit idle mode, in other words, -enter- the mode in which RCU
328  * read-side critical sections can occur.
329  *
330  * If you add or remove a call to ct_idle_exit(), be sure to test with
331  * CONFIG_RCU_EQS_DEBUG=y.
332  */
333 void noinstr ct_idle_exit(void)
334 {
335         unsigned long flags;
336
337         raw_local_irq_save(flags);
338         ct_kernel_enter(false, RCU_DYNTICKS_IDX - CONTEXT_IDLE);
339         raw_local_irq_restore(flags);
340 }
341 EXPORT_SYMBOL_GPL(ct_idle_exit);
342
343 /**
344  * ct_irq_enter - inform RCU that current CPU is entering irq away from idle
345  *
346  * Enter an interrupt handler, which might possibly result in exiting
347  * idle mode, in other words, entering the mode in which read-side critical
348  * sections can occur.  The caller must have disabled interrupts.
349  *
350  * Note that the Linux kernel is fully capable of entering an interrupt
351  * handler that it never exits, for example when doing upcalls to user mode!
352  * This code assumes that the idle loop never does upcalls to user mode.
353  * If your architecture's idle loop does do upcalls to user mode (or does
354  * anything else that results in unbalanced calls to the irq_enter() and
355  * irq_exit() functions), RCU will give you what you deserve, good and hard.
356  * But very infrequently and irreproducibly.
357  *
358  * Use things like work queues to work around this limitation.
359  *
360  * You have been warned.
361  *
362  * If you add or remove a call to ct_irq_enter(), be sure to test with
363  * CONFIG_RCU_EQS_DEBUG=y.
364  */
365 noinstr void ct_irq_enter(void)
366 {
367         lockdep_assert_irqs_disabled();
368         ct_nmi_enter();
369 }
370
371 /**
372  * ct_irq_exit - inform RCU that current CPU is exiting irq towards idle
373  *
374  * Exit from an interrupt handler, which might possibly result in entering
375  * idle mode, in other words, leaving the mode in which read-side critical
376  * sections can occur.  The caller must have disabled interrupts.
377  *
378  * This code assumes that the idle loop never does anything that might
379  * result in unbalanced calls to irq_enter() and irq_exit().  If your
380  * architecture's idle loop violates this assumption, RCU will give you what
381  * you deserve, good and hard.  But very infrequently and irreproducibly.
382  *
383  * Use things like work queues to work around this limitation.
384  *
385  * You have been warned.
386  *
387  * If you add or remove a call to ct_irq_exit(), be sure to test with
388  * CONFIG_RCU_EQS_DEBUG=y.
389  */
390 noinstr void ct_irq_exit(void)
391 {
392         lockdep_assert_irqs_disabled();
393         ct_nmi_exit();
394 }
395
396 /*
397  * Wrapper for ct_irq_enter() where interrupts are enabled.
398  *
399  * If you add or remove a call to ct_irq_enter_irqson(), be sure to test
400  * with CONFIG_RCU_EQS_DEBUG=y.
401  */
402 void ct_irq_enter_irqson(void)
403 {
404         unsigned long flags;
405
406         local_irq_save(flags);
407         ct_irq_enter();
408         local_irq_restore(flags);
409 }
410
411 /*
412  * Wrapper for ct_irq_exit() where interrupts are enabled.
413  *
414  * If you add or remove a call to ct_irq_exit_irqson(), be sure to test
415  * with CONFIG_RCU_EQS_DEBUG=y.
416  */
417 void ct_irq_exit_irqson(void)
418 {
419         unsigned long flags;
420
421         local_irq_save(flags);
422         ct_irq_exit();
423         local_irq_restore(flags);
424 }
425 #else
426 static __always_inline void ct_kernel_exit(bool user, int offset) { }
427 static __always_inline void ct_kernel_enter(bool user, int offset) { }
428 #endif /* #ifdef CONFIG_CONTEXT_TRACKING_IDLE */
429
430 #ifdef CONFIG_CONTEXT_TRACKING_USER
431
432 #define CREATE_TRACE_POINTS
433 #include <trace/events/context_tracking.h>
434
435 DEFINE_STATIC_KEY_FALSE(context_tracking_key);
436 EXPORT_SYMBOL_GPL(context_tracking_key);
437
438 static noinstr bool context_tracking_recursion_enter(void)
439 {
440         int recursion;
441
442         recursion = __this_cpu_inc_return(context_tracking.recursion);
443         if (recursion == 1)
444                 return true;
445
446         WARN_ONCE((recursion < 1), "Invalid context tracking recursion value %d\n", recursion);
447         __this_cpu_dec(context_tracking.recursion);
448
449         return false;
450 }
451
452 static __always_inline void context_tracking_recursion_exit(void)
453 {
454         __this_cpu_dec(context_tracking.recursion);
455 }
456
457 /**
458  * __ct_user_enter - Inform the context tracking that the CPU is going
459  *                   to enter user or guest space mode.
460  *
461  * This function must be called right before we switch from the kernel
462  * to user or guest space, when it's guaranteed the remaining kernel
463  * instructions to execute won't use any RCU read side critical section
464  * because this function sets RCU in extended quiescent state.
465  */
466 void noinstr __ct_user_enter(enum ctx_state state)
467 {
468         struct context_tracking *ct = this_cpu_ptr(&context_tracking);
469         lockdep_assert_irqs_disabled();
470
471         /* Kernel threads aren't supposed to go to userspace */
472         WARN_ON_ONCE(!current->mm);
473
474         if (!context_tracking_recursion_enter())
475                 return;
476
477         if (__ct_state() != state) {
478                 if (ct->active) {
479                         /*
480                          * At this stage, only low level arch entry code remains and
481                          * then we'll run in userspace. We can assume there won't be
482                          * any RCU read-side critical section until the next call to
483                          * user_exit() or ct_irq_enter(). Let's remove RCU's dependency
484                          * on the tick.
485                          */
486                         if (state == CONTEXT_USER) {
487                                 instrumentation_begin();
488                                 trace_user_enter(0);
489                                 vtime_user_enter(current);
490                                 instrumentation_end();
491                         }
492                         /*
493                          * Other than generic entry implementation, we may be past the last
494                          * rescheduling opportunity in the entry code. Trigger a self IPI
495                          * that will fire and reschedule once we resume in user/guest mode.
496                          */
497                         rcu_irq_work_resched();
498
499                         /*
500                          * Enter RCU idle mode right before resuming userspace.  No use of RCU
501                          * is permitted between this call and rcu_eqs_exit(). This way the
502                          * CPU doesn't need to maintain the tick for RCU maintenance purposes
503                          * when the CPU runs in userspace.
504                          */
505                         ct_kernel_exit(true, RCU_DYNTICKS_IDX + state);
506
507                         /*
508                          * Special case if we only track user <-> kernel transitions for tickless
509                          * cputime accounting but we don't support RCU extended quiescent state.
510                          * In this we case we don't care about any concurrency/ordering.
511                          */
512                         if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE))
513                                 atomic_set(&ct->state, state);
514                 } else {
515                         /*
516                          * Even if context tracking is disabled on this CPU, because it's outside
517                          * the full dynticks mask for example, we still have to keep track of the
518                          * context transitions and states to prevent inconsistency on those of
519                          * other CPUs.
520                          * If a task triggers an exception in userspace, sleep on the exception
521                          * handler and then migrate to another CPU, that new CPU must know where
522                          * the exception returns by the time we call exception_exit().
523                          * This information can only be provided by the previous CPU when it called
524                          * exception_enter().
525                          * OTOH we can spare the calls to vtime and RCU when context_tracking.active
526                          * is false because we know that CPU is not tickless.
527                          */
528                         if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE)) {
529                                 /* Tracking for vtime only, no concurrent RCU EQS accounting */
530                                 atomic_set(&ct->state, state);
531                         } else {
532                                 /*
533                                  * Tracking for vtime and RCU EQS. Make sure we don't race
534                                  * with NMIs. OTOH we don't care about ordering here since
535                                  * RCU only requires RCU_DYNTICKS_IDX increments to be fully
536                                  * ordered.
537                                  */
538                                 atomic_add(state, &ct->state);
539                         }
540                 }
541         }
542         context_tracking_recursion_exit();
543 }
544 EXPORT_SYMBOL_GPL(__ct_user_enter);
545
546 /*
547  * OBSOLETE:
548  * This function should be noinstr but the below local_irq_restore() is
549  * unsafe because it involves illegal RCU uses through tracing and lockdep.
550  * This is unlikely to be fixed as this function is obsolete. The preferred
551  * way is to call __context_tracking_enter() through user_enter_irqoff()
552  * or context_tracking_guest_enter(). It should be the arch entry code
553  * responsibility to call into context tracking with IRQs disabled.
554  */
555 void ct_user_enter(enum ctx_state state)
556 {
557         unsigned long flags;
558
559         /*
560          * Some contexts may involve an exception occuring in an irq,
561          * leading to that nesting:
562          * ct_irq_enter() rcu_eqs_exit(true) rcu_eqs_enter(true) ct_irq_exit()
563          * This would mess up the dyntick_nesting count though. And rcu_irq_*()
564          * helpers are enough to protect RCU uses inside the exception. So
565          * just return immediately if we detect we are in an IRQ.
566          */
567         if (in_interrupt())
568                 return;
569
570         local_irq_save(flags);
571         __ct_user_enter(state);
572         local_irq_restore(flags);
573 }
574 NOKPROBE_SYMBOL(ct_user_enter);
575 EXPORT_SYMBOL_GPL(ct_user_enter);
576
577 /**
578  * user_enter_callable() - Unfortunate ASM callable version of user_enter() for
579  *                         archs that didn't manage to check the context tracking
580  *                         static key from low level code.
581  *
582  * This OBSOLETE function should be noinstr but it unsafely calls
583  * local_irq_restore(), involving illegal RCU uses through tracing and lockdep.
584  * This is unlikely to be fixed as this function is obsolete. The preferred
585  * way is to call user_enter_irqoff(). It should be the arch entry code
586  * responsibility to call into context tracking with IRQs disabled.
587  */
588 void user_enter_callable(void)
589 {
590         user_enter();
591 }
592 NOKPROBE_SYMBOL(user_enter_callable);
593
594 /**
595  * __ct_user_exit - Inform the context tracking that the CPU is
596  *                  exiting user or guest mode and entering the kernel.
597  *
598  * This function must be called after we entered the kernel from user or
599  * guest space before any use of RCU read side critical section. This
600  * potentially include any high level kernel code like syscalls, exceptions,
601  * signal handling, etc...
602  *
603  * This call supports re-entrancy. This way it can be called from any exception
604  * handler without needing to know if we came from userspace or not.
605  */
606 void noinstr __ct_user_exit(enum ctx_state state)
607 {
608         struct context_tracking *ct = this_cpu_ptr(&context_tracking);
609
610         if (!context_tracking_recursion_enter())
611                 return;
612
613         if (__ct_state() == state) {
614                 if (ct->active) {
615                         /*
616                          * Exit RCU idle mode while entering the kernel because it can
617                          * run a RCU read side critical section anytime.
618                          */
619                         ct_kernel_enter(true, RCU_DYNTICKS_IDX - state);
620                         if (state == CONTEXT_USER) {
621                                 instrumentation_begin();
622                                 vtime_user_exit(current);
623                                 trace_user_exit(0);
624                                 instrumentation_end();
625                         }
626
627                         /*
628                          * Special case if we only track user <-> kernel transitions for tickless
629                          * cputime accounting but we don't support RCU extended quiescent state.
630                          * In this we case we don't care about any concurrency/ordering.
631                          */
632                         if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE))
633                                 atomic_set(&ct->state, CONTEXT_KERNEL);
634
635                 } else {
636                         if (!IS_ENABLED(CONFIG_CONTEXT_TRACKING_IDLE)) {
637                                 /* Tracking for vtime only, no concurrent RCU EQS accounting */
638                                 atomic_set(&ct->state, CONTEXT_KERNEL);
639                         } else {
640                                 /*
641                                  * Tracking for vtime and RCU EQS. Make sure we don't race
642                                  * with NMIs. OTOH we don't care about ordering here since
643                                  * RCU only requires RCU_DYNTICKS_IDX increments to be fully
644                                  * ordered.
645                                  */
646                                 atomic_sub(state, &ct->state);
647                         }
648                 }
649         }
650         context_tracking_recursion_exit();
651 }
652 EXPORT_SYMBOL_GPL(__ct_user_exit);
653
654 /*
655  * OBSOLETE:
656  * This function should be noinstr but the below local_irq_save() is
657  * unsafe because it involves illegal RCU uses through tracing and lockdep.
658  * This is unlikely to be fixed as this function is obsolete. The preferred
659  * way is to call __context_tracking_exit() through user_exit_irqoff()
660  * or context_tracking_guest_exit(). It should be the arch entry code
661  * responsibility to call into context tracking with IRQs disabled.
662  */
663 void ct_user_exit(enum ctx_state state)
664 {
665         unsigned long flags;
666
667         if (in_interrupt())
668                 return;
669
670         local_irq_save(flags);
671         __ct_user_exit(state);
672         local_irq_restore(flags);
673 }
674 NOKPROBE_SYMBOL(ct_user_exit);
675 EXPORT_SYMBOL_GPL(ct_user_exit);
676
677 /**
678  * user_exit_callable() - Unfortunate ASM callable version of user_exit() for
679  *                        archs that didn't manage to check the context tracking
680  *                        static key from low level code.
681  *
682  * This OBSOLETE function should be noinstr but it unsafely calls local_irq_save(),
683  * involving illegal RCU uses through tracing and lockdep. This is unlikely
684  * to be fixed as this function is obsolete. The preferred way is to call
685  * user_exit_irqoff(). It should be the arch entry code responsibility to
686  * call into context tracking with IRQs disabled.
687  */
688 void user_exit_callable(void)
689 {
690         user_exit();
691 }
692 NOKPROBE_SYMBOL(user_exit_callable);
693
694 void __init ct_cpu_track_user(int cpu)
695 {
696         static __initdata bool initialized = false;
697
698         if (!per_cpu(context_tracking.active, cpu)) {
699                 per_cpu(context_tracking.active, cpu) = true;
700                 static_branch_inc(&context_tracking_key);
701         }
702
703         if (initialized)
704                 return;
705
706 #ifdef CONFIG_HAVE_TIF_NOHZ
707         /*
708          * Set TIF_NOHZ to init/0 and let it propagate to all tasks through fork
709          * This assumes that init is the only task at this early boot stage.
710          */
711         set_tsk_thread_flag(&init_task, TIF_NOHZ);
712 #endif
713         WARN_ON_ONCE(!tasklist_empty());
714
715         initialized = true;
716 }
717
718 #ifdef CONFIG_CONTEXT_TRACKING_USER_FORCE
719 void __init context_tracking_init(void)
720 {
721         int cpu;
722
723         for_each_possible_cpu(cpu)
724                 ct_cpu_track_user(cpu);
725 }
726 #endif
727
728 #endif /* #ifdef CONFIG_CONTEXT_TRACKING_USER */