2011-06-17 16:53:19 -06:00
|
|
|
/*
|
|
|
|
* Read-Copy Update definitions shared among RCU implementations.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2013-12-03 11:02:52 -07:00
|
|
|
* along with this program; if not, you can access it online at
|
|
|
|
* http://www.gnu.org/licenses/gpl-2.0.html.
|
2011-06-17 16:53:19 -06:00
|
|
|
*
|
|
|
|
* Copyright IBM Corporation, 2011
|
|
|
|
*
|
|
|
|
* Author: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __LINUX_RCU_H
|
|
|
|
#define __LINUX_RCU_H
|
|
|
|
|
2014-02-19 12:33:27 -07:00
|
|
|
#include <trace/events/rcu.h>
|
2011-06-21 01:13:44 -06:00
|
|
|
#ifdef CONFIG_RCU_TRACE
|
|
|
|
#define RCU_TRACE(stmt) stmt
|
|
|
|
#else /* #ifdef CONFIG_RCU_TRACE */
|
|
|
|
#define RCU_TRACE(stmt)
|
|
|
|
#endif /* #else #ifdef CONFIG_RCU_TRACE */
|
|
|
|
|
2011-10-31 16:01:54 -06:00
|
|
|
/*
|
|
|
|
* Process-level increment to ->dynticks_nesting field. This allows for
|
|
|
|
* architectures that use half-interrupts and half-exceptions from
|
|
|
|
* process context.
|
2011-11-17 17:55:56 -07:00
|
|
|
*
|
|
|
|
* DYNTICK_TASK_NEST_MASK defines a field of width DYNTICK_TASK_NEST_WIDTH
|
|
|
|
* that counts the number of process-based reasons why RCU cannot
|
|
|
|
* consider the corresponding CPU to be idle, and DYNTICK_TASK_NEST_VALUE
|
|
|
|
* is the value used to increment or decrement this field.
|
|
|
|
*
|
|
|
|
* The rest of the bits could in principle be used to count interrupts,
|
|
|
|
* but this would mean that a negative-one value in the interrupt
|
|
|
|
* field could incorrectly zero out the DYNTICK_TASK_NEST_MASK field.
|
|
|
|
* We therefore provide a two-bit guard field defined by DYNTICK_TASK_MASK
|
|
|
|
* that is set to DYNTICK_TASK_FLAG upon initial exit from idle.
|
|
|
|
* The DYNTICK_TASK_EXIT_IDLE value is thus the combined value used upon
|
|
|
|
* initial exit from idle.
|
2011-10-31 16:01:54 -06:00
|
|
|
*/
|
2011-11-17 17:55:56 -07:00
|
|
|
#define DYNTICK_TASK_NEST_WIDTH 7
|
|
|
|
#define DYNTICK_TASK_NEST_VALUE ((LLONG_MAX >> DYNTICK_TASK_NEST_WIDTH) + 1)
|
|
|
|
#define DYNTICK_TASK_NEST_MASK (LLONG_MAX - DYNTICK_TASK_NEST_VALUE + 1)
|
|
|
|
#define DYNTICK_TASK_FLAG ((DYNTICK_TASK_NEST_VALUE / 8) * 2)
|
|
|
|
#define DYNTICK_TASK_MASK ((DYNTICK_TASK_NEST_VALUE / 8) * 3)
|
|
|
|
#define DYNTICK_TASK_EXIT_IDLE (DYNTICK_TASK_NEST_VALUE + \
|
|
|
|
DYNTICK_TASK_FLAG)
|
2011-10-31 16:01:54 -06:00
|
|
|
|
2017-02-20 15:57:17 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Grace-period counter management.
|
|
|
|
*/
|
|
|
|
|
2017-03-21 11:35:57 -06:00
|
|
|
#define RCU_SEQ_CTR_SHIFT 2
|
2017-03-21 08:28:14 -06:00
|
|
|
#define RCU_SEQ_STATE_MASK ((1 << RCU_SEQ_CTR_SHIFT) - 1)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the counter portion of a sequence number previously returned
|
|
|
|
* by rcu_seq_snap() or rcu_seq_current().
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_seq_ctr(unsigned long s)
|
|
|
|
{
|
|
|
|
return s >> RCU_SEQ_CTR_SHIFT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the state portion of a sequence number previously returned
|
|
|
|
* by rcu_seq_snap() or rcu_seq_current().
|
|
|
|
*/
|
|
|
|
static inline int rcu_seq_state(unsigned long s)
|
|
|
|
{
|
|
|
|
return s & RCU_SEQ_STATE_MASK;
|
|
|
|
}
|
|
|
|
|
2017-03-22 16:26:18 -06:00
|
|
|
/*
|
|
|
|
* Set the state portion of the pointed-to sequence number.
|
|
|
|
* The caller is responsible for preventing conflicting updates.
|
|
|
|
*/
|
|
|
|
static inline void rcu_seq_set_state(unsigned long *sp, int newstate)
|
|
|
|
{
|
|
|
|
WARN_ON_ONCE(newstate & ~RCU_SEQ_STATE_MASK);
|
|
|
|
WRITE_ONCE(*sp, (*sp & ~RCU_SEQ_STATE_MASK) + newstate);
|
|
|
|
}
|
|
|
|
|
2017-02-20 15:57:17 -07:00
|
|
|
/* Adjust sequence number for start of update-side operation. */
|
|
|
|
static inline void rcu_seq_start(unsigned long *sp)
|
|
|
|
{
|
|
|
|
WRITE_ONCE(*sp, *sp + 1);
|
|
|
|
smp_mb(); /* Ensure update-side operation after counter increment. */
|
2017-03-21 08:28:14 -06:00
|
|
|
WARN_ON_ONCE(rcu_seq_state(*sp) != 1);
|
2017-02-20 15:57:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Adjust sequence number for end of update-side operation. */
|
|
|
|
static inline void rcu_seq_end(unsigned long *sp)
|
|
|
|
{
|
|
|
|
smp_mb(); /* Ensure update-side operation before counter increment. */
|
2017-03-21 08:28:14 -06:00
|
|
|
WARN_ON_ONCE(!rcu_seq_state(*sp));
|
|
|
|
WRITE_ONCE(*sp, (*sp | RCU_SEQ_STATE_MASK) + 1);
|
2017-02-20 15:57:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Take a snapshot of the update side's sequence number. */
|
|
|
|
static inline unsigned long rcu_seq_snap(unsigned long *sp)
|
|
|
|
{
|
|
|
|
unsigned long s;
|
|
|
|
|
2017-03-21 08:28:14 -06:00
|
|
|
s = (READ_ONCE(*sp) + 2 * RCU_SEQ_STATE_MASK + 1) & ~RCU_SEQ_STATE_MASK;
|
2017-02-20 15:57:17 -07:00
|
|
|
smp_mb(); /* Above access must not bleed into critical section. */
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2017-03-13 17:48:18 -06:00
|
|
|
/* Return the current value the update side's sequence number, no ordering. */
|
|
|
|
static inline unsigned long rcu_seq_current(unsigned long *sp)
|
|
|
|
{
|
|
|
|
return READ_ONCE(*sp);
|
|
|
|
}
|
|
|
|
|
2017-02-20 15:57:17 -07:00
|
|
|
/*
|
|
|
|
* Given a snapshot from rcu_seq_snap(), determine whether or not a
|
|
|
|
* full update-side operation has occurred.
|
|
|
|
*/
|
|
|
|
static inline bool rcu_seq_done(unsigned long *sp, unsigned long s)
|
|
|
|
{
|
|
|
|
return ULONG_CMP_GE(READ_ONCE(*sp), s);
|
|
|
|
}
|
|
|
|
|
2011-06-17 16:53:19 -06:00
|
|
|
/*
|
|
|
|
* debug_rcu_head_queue()/debug_rcu_head_unqueue() are used internally
|
|
|
|
* by call_rcu() and rcu callback execution, and are therefore not part of the
|
|
|
|
* RCU API. Leaving in rcupdate.h because they are used by all RCU flavors.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
|
|
|
|
# define STATE_RCU_HEAD_READY 0
|
|
|
|
# define STATE_RCU_HEAD_QUEUED 1
|
|
|
|
|
|
|
|
extern struct debug_obj_descr rcuhead_debug_descr;
|
|
|
|
|
2013-04-23 14:20:57 -06:00
|
|
|
static inline int debug_rcu_head_queue(struct rcu_head *head)
|
2011-06-17 16:53:19 -06:00
|
|
|
{
|
2013-04-23 14:20:57 -06:00
|
|
|
int r1;
|
|
|
|
|
|
|
|
r1 = debug_object_activate(head, &rcuhead_debug_descr);
|
2011-06-17 16:53:19 -06:00
|
|
|
debug_object_active_state(head, &rcuhead_debug_descr,
|
|
|
|
STATE_RCU_HEAD_READY,
|
|
|
|
STATE_RCU_HEAD_QUEUED);
|
2013-04-23 14:20:57 -06:00
|
|
|
return r1;
|
2011-06-17 16:53:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void debug_rcu_head_unqueue(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
debug_object_active_state(head, &rcuhead_debug_descr,
|
|
|
|
STATE_RCU_HEAD_QUEUED,
|
|
|
|
STATE_RCU_HEAD_READY);
|
|
|
|
debug_object_deactivate(head, &rcuhead_debug_descr);
|
|
|
|
}
|
|
|
|
#else /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
|
2013-04-23 14:20:57 -06:00
|
|
|
static inline int debug_rcu_head_queue(struct rcu_head *head)
|
2011-06-17 16:53:19 -06:00
|
|
|
{
|
2013-04-23 14:20:57 -06:00
|
|
|
return 0;
|
2011-06-17 16:53:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void debug_rcu_head_unqueue(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
|
|
|
|
|
2013-11-11 08:11:24 -07:00
|
|
|
void kfree(const void *);
|
2011-06-17 16:53:19 -06:00
|
|
|
|
2014-06-23 14:48:28 -06:00
|
|
|
/*
|
|
|
|
* Reclaim the specified callback, either by invoking it (non-lazy case)
|
|
|
|
* or freeing it directly (lazy case). Return true if lazy, false otherwise.
|
|
|
|
*/
|
2013-07-12 14:50:28 -06:00
|
|
|
static inline bool __rcu_reclaim(const char *rn, struct rcu_head *head)
|
2011-06-17 16:53:19 -06:00
|
|
|
{
|
|
|
|
unsigned long offset = (unsigned long)head->func;
|
|
|
|
|
2013-10-28 10:22:24 -06:00
|
|
|
rcu_lock_acquire(&rcu_callback_map);
|
2011-06-17 16:53:19 -06:00
|
|
|
if (__is_kfree_rcu_offset(offset)) {
|
2017-01-23 12:55:43 -07:00
|
|
|
RCU_TRACE(trace_rcu_invoke_kfree_callback(rn, head, offset);)
|
2011-06-17 16:53:19 -06:00
|
|
|
kfree((void *)head - offset);
|
2013-10-28 10:22:24 -06:00
|
|
|
rcu_lock_release(&rcu_callback_map);
|
2014-06-23 14:48:28 -06:00
|
|
|
return true;
|
2011-06-17 16:53:19 -06:00
|
|
|
} else {
|
2017-01-23 12:55:43 -07:00
|
|
|
RCU_TRACE(trace_rcu_invoke_callback(rn, head);)
|
2011-06-17 16:53:19 -06:00
|
|
|
head->func(head);
|
2013-10-28 10:22:24 -06:00
|
|
|
rcu_lock_release(&rcu_callback_map);
|
2014-06-23 14:48:28 -06:00
|
|
|
return false;
|
2011-06-17 16:53:19 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-19 13:49:17 -06:00
|
|
|
#ifdef CONFIG_RCU_STALL_COMMON
|
|
|
|
|
|
|
|
extern int rcu_cpu_stall_suppress;
|
|
|
|
int rcu_jiffies_till_stall_check(void);
|
|
|
|
|
|
|
|
#endif /* #ifdef CONFIG_RCU_STALL_COMMON */
|
|
|
|
|
2013-08-17 19:08:37 -06:00
|
|
|
/*
|
|
|
|
* Strings used in tracepoints need to be exported via the
|
|
|
|
* tracing system such that tools like perf and trace-cmd can
|
|
|
|
* translate the string address pointers to actual text.
|
|
|
|
*/
|
|
|
|
#define TPS(x) tracepoint_string(x)
|
|
|
|
|
2017-05-03 13:28:59 -06:00
|
|
|
/*
|
|
|
|
* Dump the ftrace buffer, but only one time per callsite per boot.
|
|
|
|
*/
|
|
|
|
#define rcu_ftrace_dump(oops_dump_mode) \
|
|
|
|
do { \
|
|
|
|
static atomic_t ___rfd_beenhere = ATOMIC_INIT(0); \
|
|
|
|
\
|
|
|
|
if (!atomic_read(&___rfd_beenhere) && \
|
|
|
|
!atomic_xchg(&___rfd_beenhere, 1)) \
|
|
|
|
ftrace_dump(oops_dump_mode); \
|
|
|
|
} while (0)
|
|
|
|
|
2014-09-19 09:32:29 -06:00
|
|
|
void rcu_early_boot_tests(void);
|
rcu: Narrow early boot window of illegal synchronous grace periods
The current preemptible RCU implementation goes through three phases
during bootup. In the first phase, there is only one CPU that is running
with preemption disabled, so that a no-op is a synchronous grace period.
In the second mid-boot phase, the scheduler is running, but RCU has
not yet gotten its kthreads spawned (and, for expedited grace periods,
workqueues are not yet running. During this time, any attempt to do
a synchronous grace period will hang the system (or complain bitterly,
depending). In the third and final phase, RCU is fully operational and
everything works normally.
This has been OK for some time, but there has recently been some
synchronous grace periods showing up during the second mid-boot phase.
This code worked "by accident" for awhile, but started failing as soon
as expedited RCU grace periods switched over to workqueues in commit
8b355e3bc140 ("rcu: Drive expedited grace periods from workqueue").
Note that the code was buggy even before this commit, as it was subject
to failure on real-time systems that forced all expedited grace periods
to run as normal grace periods (for example, using the rcu_normal ksysfs
parameter). The callchain from the failure case is as follows:
early_amd_iommu_init()
|-> acpi_put_table(ivrs_base);
|-> acpi_tb_put_table(table_desc);
|-> acpi_tb_invalidate_table(table_desc);
|-> acpi_tb_release_table(...)
|-> acpi_os_unmap_memory
|-> acpi_os_unmap_iomem
|-> acpi_os_map_cleanup
|-> synchronize_rcu_expedited
The kernel showing this callchain was built with CONFIG_PREEMPT_RCU=y,
which caused the code to try using workqueues before they were
initialized, which did not go well.
This commit therefore reworks RCU to permit synchronous grace periods
to proceed during this mid-boot phase. This commit is therefore a
fix to a regression introduced in v4.9, and is therefore being put
forward post-merge-window in v4.10.
This commit sets a flag from the existing rcu_scheduler_starting()
function which causes all synchronous grace periods to take the expedited
path. The expedited path now checks this flag, using the requesting task
to drive the expedited grace period forward during the mid-boot phase.
Finally, this flag is updated by a core_initcall() function named
rcu_exp_runtime_mode(), which causes the runtime codepaths to be used.
Note that this arrangement assumes that tasks are not sent POSIX signals
(or anything similar) from the time that the first task is spawned
through core_initcall() time.
Fixes: 8b355e3bc140 ("rcu: Drive expedited grace periods from workqueue")
Reported-by: "Zheng, Lv" <lv.zheng@intel.com>
Reported-by: Borislav Petkov <bp@alien8.de>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Tested-by: Stan Kain <stan.kain@gmail.com>
Tested-by: Ivan <waffolz@hotmail.com>
Tested-by: Emanuel Castelo <emanuel.castelo@gmail.com>
Tested-by: Bruno Pesavento <bpesavento@infinito.it>
Tested-by: Borislav Petkov <bp@suse.de>
Tested-by: Frederic Bezies <fredbezies@gmail.com>
Cc: <stable@vger.kernel.org> # 4.9.0-
2017-01-10 03:28:26 -07:00
|
|
|
void rcu_test_sync_prims(void);
|
2014-09-19 09:32:29 -06:00
|
|
|
|
2014-12-09 02:53:34 -07:00
|
|
|
/*
|
|
|
|
* This function really isn't for public consumption, but RCU is special in
|
|
|
|
* that context switches can allow the state machine to make progress.
|
|
|
|
*/
|
|
|
|
extern void resched_cpu(int cpu);
|
|
|
|
|
2017-03-14 15:29:53 -06:00
|
|
|
#if defined(SRCU) || !defined(TINY_RCU)
|
|
|
|
|
|
|
|
#include <linux/rcu_node_tree.h>
|
|
|
|
|
|
|
|
extern int rcu_num_lvls;
|
2017-03-15 14:11:11 -06:00
|
|
|
extern int num_rcu_lvl[];
|
2017-03-14 15:29:53 -06:00
|
|
|
extern int rcu_num_nodes;
|
|
|
|
static bool rcu_fanout_exact;
|
|
|
|
static int rcu_fanout_leaf;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute the per-level fanout, either using the exact fanout specified
|
|
|
|
* or balancing the tree, depending on the rcu_fanout_exact boot parameter.
|
|
|
|
*/
|
|
|
|
static inline void rcu_init_levelspread(int *levelspread, const int *levelcnt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (rcu_fanout_exact) {
|
|
|
|
levelspread[rcu_num_lvls - 1] = rcu_fanout_leaf;
|
|
|
|
for (i = rcu_num_lvls - 2; i >= 0; i--)
|
|
|
|
levelspread[i] = RCU_FANOUT;
|
|
|
|
} else {
|
|
|
|
int ccur;
|
|
|
|
int cprv;
|
|
|
|
|
|
|
|
cprv = nr_cpu_ids;
|
|
|
|
for (i = rcu_num_lvls - 1; i >= 0; i--) {
|
|
|
|
ccur = levelcnt[i];
|
|
|
|
levelspread[i] = (cprv + ccur - 1) / ccur;
|
|
|
|
cprv = ccur;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-15 14:07:53 -06:00
|
|
|
/*
|
|
|
|
* Do a full breadth-first scan of the rcu_node structures for the
|
|
|
|
* specified rcu_state structure.
|
|
|
|
*/
|
|
|
|
#define rcu_for_each_node_breadth_first(rsp, rnp) \
|
|
|
|
for ((rnp) = &(rsp)->node[0]; \
|
|
|
|
(rnp) < &(rsp)->node[rcu_num_nodes]; (rnp)++)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a breadth-first scan of the non-leaf rcu_node structures for the
|
|
|
|
* specified rcu_state structure. Note that if there is a singleton
|
|
|
|
* rcu_node tree with but one rcu_node structure, this loop is a no-op.
|
|
|
|
*/
|
|
|
|
#define rcu_for_each_nonleaf_node_breadth_first(rsp, rnp) \
|
|
|
|
for ((rnp) = &(rsp)->node[0]; \
|
|
|
|
(rnp) < (rsp)->level[rcu_num_lvls - 1]; (rnp)++)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the leaves of the rcu_node hierarchy for the specified rcu_state
|
|
|
|
* structure. Note that if there is a singleton rcu_node tree with but
|
|
|
|
* one rcu_node structure, this loop -will- visit the rcu_node structure.
|
|
|
|
* It is still a leaf node, even if it is also the root node.
|
|
|
|
*/
|
|
|
|
#define rcu_for_each_leaf_node(rsp, rnp) \
|
|
|
|
for ((rnp) = (rsp)->level[rcu_num_lvls - 1]; \
|
|
|
|
(rnp) < &(rsp)->node[rcu_num_nodes]; (rnp)++)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Iterate over all possible CPUs in a leaf RCU node.
|
|
|
|
*/
|
|
|
|
#define for_each_leaf_node_possible_cpu(rnp, cpu) \
|
|
|
|
for ((cpu) = cpumask_next(rnp->grplo - 1, cpu_possible_mask); \
|
|
|
|
cpu <= rnp->grphi; \
|
|
|
|
cpu = cpumask_next((cpu), cpu_possible_mask))
|
|
|
|
|
2017-03-14 15:29:53 -06:00
|
|
|
#endif /* #if defined(SRCU) || !defined(TINY_RCU) */
|
|
|
|
|
2017-05-03 10:51:55 -06:00
|
|
|
#ifdef CONFIG_TINY_RCU
|
|
|
|
/* Tiny RCU doesn't expedite, as its purpose in life is instead to be tiny. */
|
|
|
|
static inline bool rcu_gp_is_normal(void) /* Internal RCU use. */
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
static inline bool rcu_gp_is_expedited(void) /* Internal RCU use. */
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_expedite_gp(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_unexpedite_gp(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#else /* #ifdef CONFIG_TINY_RCU */
|
|
|
|
bool rcu_gp_is_normal(void); /* Internal RCU use. */
|
|
|
|
bool rcu_gp_is_expedited(void); /* Internal RCU use. */
|
|
|
|
void rcu_expedite_gp(void);
|
|
|
|
void rcu_unexpedite_gp(void);
|
|
|
|
void rcupdate_announce_bootup_oddness(void);
|
|
|
|
#endif /* #else #ifdef CONFIG_TINY_RCU */
|
|
|
|
|
2017-05-03 12:13:24 -06:00
|
|
|
#define RCU_SCHEDULER_INACTIVE 0
|
|
|
|
#define RCU_SCHEDULER_INIT 1
|
|
|
|
#define RCU_SCHEDULER_RUNNING 2
|
|
|
|
|
2017-05-03 14:45:51 -06:00
|
|
|
#ifdef CONFIG_TINY_RCU
|
|
|
|
static inline void rcu_request_urgent_qs_task(struct task_struct *t) { }
|
|
|
|
#else /* #ifdef CONFIG_TINY_RCU */
|
|
|
|
void rcu_request_urgent_qs_task(struct task_struct *t);
|
|
|
|
#endif /* #else #ifdef CONFIG_TINY_RCU */
|
|
|
|
|
2017-05-03 11:22:57 -06:00
|
|
|
enum rcutorture_type {
|
|
|
|
RCU_FLAVOR,
|
|
|
|
RCU_BH_FLAVOR,
|
|
|
|
RCU_SCHED_FLAVOR,
|
|
|
|
RCU_TASKS_FLAVOR,
|
|
|
|
SRCU_FLAVOR,
|
|
|
|
INVALID_RCU_FLAVOR
|
|
|
|
};
|
|
|
|
|
|
|
|
#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
|
|
|
|
void rcutorture_get_gp_data(enum rcutorture_type test_type, int *flags,
|
|
|
|
unsigned long *gpnum, unsigned long *completed);
|
|
|
|
void rcutorture_record_test_transition(void);
|
|
|
|
void rcutorture_record_progress(unsigned long vernum);
|
|
|
|
void do_trace_rcu_torture_read(const char *rcutorturename,
|
|
|
|
struct rcu_head *rhp,
|
|
|
|
unsigned long secs,
|
|
|
|
unsigned long c_old,
|
|
|
|
unsigned long c);
|
|
|
|
#else
|
|
|
|
static inline void rcutorture_get_gp_data(enum rcutorture_type test_type,
|
|
|
|
int *flags,
|
|
|
|
unsigned long *gpnum,
|
|
|
|
unsigned long *completed)
|
|
|
|
{
|
|
|
|
*flags = 0;
|
|
|
|
*gpnum = 0;
|
|
|
|
*completed = 0;
|
|
|
|
}
|
|
|
|
static inline void rcutorture_record_test_transition(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
static inline void rcutorture_record_progress(unsigned long vernum)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_RCU_TRACE
|
|
|
|
void do_trace_rcu_torture_read(const char *rcutorturename,
|
|
|
|
struct rcu_head *rhp,
|
|
|
|
unsigned long secs,
|
|
|
|
unsigned long c_old,
|
|
|
|
unsigned long c);
|
|
|
|
#else
|
|
|
|
#define do_trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
|
|
|
|
do { } while (0)
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_TINY_SRCU
|
|
|
|
|
|
|
|
static inline void srcutorture_get_gp_data(enum rcutorture_type test_type,
|
|
|
|
struct srcu_struct *sp, int *flags,
|
|
|
|
unsigned long *gpnum,
|
|
|
|
unsigned long *completed)
|
|
|
|
{
|
|
|
|
if (test_type != SRCU_FLAVOR)
|
|
|
|
return;
|
|
|
|
*flags = 0;
|
|
|
|
*completed = sp->srcu_gp_seq;
|
|
|
|
*gpnum = *completed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#elif defined(CONFIG_TREE_SRCU)
|
|
|
|
|
|
|
|
void srcutorture_get_gp_data(enum rcutorture_type test_type,
|
|
|
|
struct srcu_struct *sp, int *flags,
|
|
|
|
unsigned long *gpnum, unsigned long *completed);
|
|
|
|
|
|
|
|
#elif defined(CONFIG_CLASSIC_SRCU)
|
|
|
|
|
|
|
|
static inline void srcutorture_get_gp_data(enum rcutorture_type test_type,
|
|
|
|
struct srcu_struct *sp, int *flags,
|
|
|
|
unsigned long *gpnum,
|
|
|
|
unsigned long *completed)
|
|
|
|
{
|
|
|
|
if (test_type != SRCU_FLAVOR)
|
|
|
|
return;
|
|
|
|
*flags = 0;
|
|
|
|
*completed = sp->completed;
|
|
|
|
*gpnum = *completed;
|
|
|
|
if (sp->batch_queue.head || sp->batch_check0.head || sp->batch_check0.head)
|
|
|
|
(*gpnum)++;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2017-05-03 14:37:16 -06:00
|
|
|
#ifdef CONFIG_TINY_RCU
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of grace periods started.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_batches_started(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of bottom-half grace periods started.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_batches_started_bh(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of sched grace periods started.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_batches_started_sched(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of grace periods completed.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_batches_completed(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of bottom-half grace periods completed.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_batches_completed_bh(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of sched grace periods completed.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_batches_completed_sched(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of expedited grace periods completed.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_exp_batches_completed(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return the number of expedited sched grace periods completed.
|
|
|
|
*/
|
|
|
|
static inline unsigned long rcu_exp_batches_completed_sched(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-04 12:31:04 -06:00
|
|
|
static inline unsigned long srcu_batches_completed(struct srcu_struct *sp)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-05-03 14:37:16 -06:00
|
|
|
static inline void rcu_force_quiescent_state(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_bh_force_quiescent_state(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void rcu_sched_force_quiescent_state(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void show_rcu_gp_kthreads(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* #ifdef CONFIG_TINY_RCU */
|
|
|
|
extern unsigned long rcutorture_testseq;
|
|
|
|
extern unsigned long rcutorture_vernum;
|
|
|
|
unsigned long rcu_batches_started(void);
|
|
|
|
unsigned long rcu_batches_started_bh(void);
|
|
|
|
unsigned long rcu_batches_started_sched(void);
|
|
|
|
unsigned long rcu_batches_completed(void);
|
|
|
|
unsigned long rcu_batches_completed_bh(void);
|
|
|
|
unsigned long rcu_batches_completed_sched(void);
|
|
|
|
unsigned long rcu_exp_batches_completed(void);
|
|
|
|
unsigned long rcu_exp_batches_completed_sched(void);
|
2017-05-04 12:31:04 -06:00
|
|
|
unsigned long srcu_batches_completed(struct srcu_struct *sp);
|
2017-05-03 14:37:16 -06:00
|
|
|
void show_rcu_gp_kthreads(void);
|
|
|
|
void rcu_force_quiescent_state(void);
|
|
|
|
void rcu_bh_force_quiescent_state(void);
|
|
|
|
void rcu_sched_force_quiescent_state(void);
|
|
|
|
#endif /* #else #ifdef CONFIG_TINY_RCU */
|
|
|
|
|
2017-05-03 13:25:50 -06:00
|
|
|
#if defined(CONFIG_RCU_NOCB_CPU_ALL)
|
|
|
|
static inline bool rcu_is_nocb_cpu(int cpu) { return true; }
|
|
|
|
#elif defined(CONFIG_RCU_NOCB_CPU)
|
|
|
|
bool rcu_is_nocb_cpu(int cpu);
|
|
|
|
#else
|
|
|
|
static inline bool rcu_is_nocb_cpu(int cpu) { return false; }
|
|
|
|
#endif
|
|
|
|
|
2011-06-17 16:53:19 -06:00
|
|
|
#endif /* __LINUX_RCU_H */
|