linux-imx

/*

 * Context tracking: Probe on high level context boundaries such as kernel

 * and userspace. This includes syscalls and exceptions entry/exit.

 *

 * This is used by RCU to remove its dependency on the timer tick while a CPU

 * runs in userspace.

 *

 *  Started by Frederic Weisbecker:

 *

 * Copyright (C) 2012 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>

 *

 * Many thanks to Gilad Ben-Yossef, Paul McKenney, Ingo Molnar, Andrew Morton,

 * Steven Rostedt, Peter Zijlstra for suggestions and improvements.

 *

 */

​

#include <linux/context_tracking.h>

#include <linux/rcupdate.h>

#include <linux/sched.h>

#include <linux/hardirq.h>

#include <linux/export.h>

#include <linux/kprobes.h>

​

#define CREATE_TRACE_POINTS

#include <trace/events/context_tracking.h>

​

DEFINE_STATIC_KEY_FALSE(context_tracking_enabled);

EXPORT_SYMBOL_GPL(context_tracking_enabled);

​

DEFINE_PER_CPU(struct context_tracking, context_tracking);

EXPORT_SYMBOL_GPL(context_tracking);

​

static bool context_tracking_recursion_enter(void)

{

    int recursion;

​

    recursion = __this_cpu_inc_return(context_tracking.recursion);

    if (recursion == 1)

        return true;

​

    WARN_ONCE((recursion < 1), "Invalid context tracking recursion value %d\n", recursion);

    __this_cpu_dec(context_tracking.recursion);

​

    return false;

}

​

static void context_tracking_recursion_exit(void)

{

    __this_cpu_dec(context_tracking.recursion);

}

​

/**

 * context_tracking_enter - Inform the context tracking that the CPU is going

 *                          enter user or guest space mode.

 *

 * This function must be called right before we switch from the kernel

 * to user or guest space, when it's guaranteed the remaining kernel

 * instructions to execute won't use any RCU read side critical section

 * because this function sets RCU in extended quiescent state.

 */

void __context_tracking_enter(enum ctx_state state)

{

    /* Kernel threads aren't supposed to go to userspace */

    WARN_ON_ONCE(!current->mm);

​

    if (!context_tracking_recursion_enter())

        return;

​

    if ( __this_cpu_read(context_tracking.state) != state) {

        if (__this_cpu_read(context_tracking.active)) {

            /*

             * At this stage, only low level arch entry code remains and

             * then we'll run in userspace. We can assume there won't be

             * any RCU read-side critical section until the next call to

             * user_exit() or rcu_irq_enter(). Let's remove RCU's dependency

             * on the tick.

             */

            if (state == CONTEXT_USER) {

                trace_user_enter(0);

                vtime_user_enter(current);

            }

            rcu_user_enter();

        }

        /*

         * Even if context tracking is disabled on this CPU, because it's outside

         * the full dynticks mask for example, we still have to keep track of the

         * context transitions and states to prevent inconsistency on those of

         * other CPUs.

         * If a task triggers an exception in userspace, sleep on the exception

         * handler and then migrate to another CPU, that new CPU must know where

         * the exception returns by the time we call exception_exit().

         * This information can only be provided by the previous CPU when it called