/** * rcu_read_lock_held() - might we be in RCU read-side critical section? * * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an RCU * read-side critical section. In absence of CONFIG_DEBUG_LOCK_ALLOC, * this assumes we are in an RCU read-side critical section unless it can * prove otherwise. This is useful for debug checks in functions that * require that they be called within an RCU read-side critical section. * * Checks debug_lockdep_rcu_enabled() to prevent false positives during boot * and while lockdep is disabled. * * Note that rcu_read_lock() and the matching rcu_read_unlock() must * occur in the same context, for example, it is illegal to invoke * rcu_read_unlock() in process context if the matching rcu_read_lock() * was invoked from within an irq handler. * * Note that rcu_read_lock() is disallowed if the CPU is either idle or * offline from an RCU perspective, so check for those as well. */ int rcu_read_lock_held(void) { if (!debug_lockdep_rcu_enabled()) return 1; if (!rcu_is_watching()) return 0; if (!rcu_lockdep_current_cpu_online()) return 0; return lock_is_held(&rcu_lock_map); }
/** * rcu_read_lock_bh_held() - might we be in RCU-bh read-side critical section? * * Check for bottom half being disabled, which covers both the * CONFIG_PROVE_RCU and not cases. Note that if someone uses * rcu_read_lock_bh(), but then later enables BH, lockdep (if enabled) * will show the situation. This is useful for debug checks in functions * that require that they be called within an RCU read-side critical * section. * * Check debug_lockdep_rcu_enabled() to prevent false positives during boot. * * Note that rcu_read_lock() is disallowed if the CPU is either idle or * offline from an RCU perspective, so check for those as well. */ int rcu_read_lock_bh_held(void) { if (!debug_lockdep_rcu_enabled()) return 1; if (rcu_is_cpu_idle()) return 0; if (!rcu_lockdep_current_cpu_online()) return 0; return in_softirq() || irqs_disabled(); }
/** * rcu_read_lock_sched_held() - might we be in RCU-sched read-side critical section? * * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an * RCU-sched read-side critical section. In absence of * CONFIG_DEBUG_LOCK_ALLOC, this assumes we are in an RCU-sched read-side * critical section unless it can prove otherwise. Note that disabling * of preemption (including disabling irqs) counts as an RCU-sched * read-side critical section. This is useful for debug checks in functions * that required that they be called within an RCU-sched read-side * critical section. * * Check debug_lockdep_rcu_enabled() to prevent false positives during boot * and while lockdep is disabled. * * Note that if the CPU is in the idle loop from an RCU point of * view (ie: that we are in the section between rcu_idle_enter() and * rcu_idle_exit()) then rcu_read_lock_held() returns false even if the CPU * did an rcu_read_lock(). The reason for this is that RCU ignores CPUs * that are in such a section, considering these as in extended quiescent * state, so such a CPU is effectively never in an RCU read-side critical * section regardless of what RCU primitives it invokes. This state of * affairs is required --- we need to keep an RCU-free window in idle * where the CPU may possibly enter into low power mode. This way we can * notice an extended quiescent state to other CPUs that started a grace * period. Otherwise we would delay any grace period as long as we run in * the idle task. * * Similarly, we avoid claiming an SRCU read lock held if the current * CPU is offline. */ int rcu_read_lock_sched_held(void) { int lockdep_opinion = 0; if (!debug_lockdep_rcu_enabled()) return 1; if (!rcu_is_watching()) return 0; if (!rcu_lockdep_current_cpu_online()) return 0; if (debug_locks) lockdep_opinion = lock_is_held(&rcu_sched_lock_map); return lockdep_opinion || !preemptible(); }