2011-06-17 22:53:19 +00: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 18:02:52 +00: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 22:53:19 +00: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 19:33:27 +00:00
|
|
|
#include <trace/events/rcu.h>
|
2011-06-21 07:13:44 +00: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 22:01:54 +00:00
|
|
|
/*
|
|
|
|
* Process-level increment to ->dynticks_nesting field. This allows for
|
|
|
|
* architectures that use half-interrupts and half-exceptions from
|
|
|
|
* process context.
|
2011-11-18 00:55:56 +00: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 22:01:54 +00:00
|
|
|
*/
|
2011-11-18 00:55:56 +00: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 22:01:54 +00:00
|
|
|
|
2017-02-20 22:57:17 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Grace-period counter management.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
WARN_ON_ONCE(!(*sp & 0x1));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
WRITE_ONCE(*sp, *sp + 1);
|
|
|
|
WARN_ON_ONCE(*sp & 0x1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Take a snapshot of the update side's sequence number. */
|
|
|
|
static inline unsigned long rcu_seq_snap(unsigned long *sp)
|
|
|
|
{
|
|
|
|
unsigned long s;
|
|
|
|
|
|
|
|
s = (READ_ONCE(*sp) + 3) & ~0x1;
|
|
|
|
smp_mb(); /* Above access must not bleed into critical section. */
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 22:53:19 +00: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 20:20:57 +00:00
|
|
|
static inline int debug_rcu_head_queue(struct rcu_head *head)
|
2011-06-17 22:53:19 +00:00
|
|
|
{
|
2013-04-23 20:20:57 +00:00
|
|
|
int r1;
|
|
|
|
|
|
|
|
r1 = debug_object_activate(head, &rcuhead_debug_descr);
|
2011-06-17 22:53:19 +00:00
|
|
|
debug_object_active_state(head, &rcuhead_debug_descr,
|
|
|
|
STATE_RCU_HEAD_READY,
|
|
|
|
STATE_RCU_HEAD_QUEUED);
|
2013-04-23 20:20:57 +00:00
|
|
|
return r1;
|
2011-06-17 22:53:19 +00: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 20:20:57 +00:00
|
|
|
static inline int debug_rcu_head_queue(struct rcu_head *head)
|
2011-06-17 22:53:19 +00:00
|
|
|
{
|
2013-04-23 20:20:57 +00:00
|
|
|
return 0;
|
2011-06-17 22:53:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void debug_rcu_head_unqueue(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
|
|
|
|
|
2013-11-11 15:11:24 +00:00
|
|
|
void kfree(const void *);
|
2011-06-17 22:53:19 +00:00
|
|
|
|
2014-06-23 20:48:28 +00: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 20:50:28 +00:00
|
|
|
static inline bool __rcu_reclaim(const char *rn, struct rcu_head *head)
|
2011-06-17 22:53:19 +00:00
|
|
|
{
|
|
|
|
unsigned long offset = (unsigned long)head->func;
|
|
|
|
|
2013-10-28 16:22:24 +00:00
|
|
|
rcu_lock_acquire(&rcu_callback_map);
|
2011-06-17 22:53:19 +00:00
|
|
|
if (__is_kfree_rcu_offset(offset)) {
|
2017-01-23 19:55:43 +00:00
|
|
|
RCU_TRACE(trace_rcu_invoke_kfree_callback(rn, head, offset);)
|
2011-06-17 22:53:19 +00:00
|
|
|
kfree((void *)head - offset);
|
2013-10-28 16:22:24 +00:00
|
|
|
rcu_lock_release(&rcu_callback_map);
|
2014-06-23 20:48:28 +00:00
|
|
|
return true;
|
2011-06-17 22:53:19 +00:00
|
|
|
} else {
|
2017-01-23 19:55:43 +00:00
|
|
|
RCU_TRACE(trace_rcu_invoke_callback(rn, head);)
|
2011-06-17 22:53:19 +00:00
|
|
|
head->func(head);
|
2013-10-28 16:22:24 +00:00
|
|
|
rcu_lock_release(&rcu_callback_map);
|
2014-06-23 20:48:28 +00:00
|
|
|
return false;
|
2011-06-17 22:53:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-19 19:49:17 +00: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-18 01:08:37 +00: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)
|
|
|
|
|
2014-09-19 15:32:29 +00: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 10:28:26 +00:00
|
|
|
void rcu_test_sync_prims(void);
|
2014-09-19 15:32:29 +00:00
|
|
|
|
2014-12-09 09:53:34 +00: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);
|
|
|
|
|
2011-06-17 22:53:19 +00:00
|
|
|
#endif /* __LINUX_RCU_H */
|