Merge branch 'rcu-tasks.2014.09.10a' into HEAD (96b46727) · Commits · 戴 / test

Documentation/RCU/stallwarn.txt

+24 −9

Original line number	Diff line number	Diff line
		@@ -56,8 +56,20 @@ RCU_STALL_RAT_DELAY
		two jiffies. (This is a cpp macro, not a kernel configuration
		parameter.)

		When a CPU detects that it is stalling, it will print a message similar
		to the following:
		rcupdate.rcu_task_stall_timeout

		This boot/sysfs parameter controls the RCU-tasks stall warning
		interval. A value of zero or less suppresses RCU-tasks stall
		warnings. A positive value sets the stall-warning interval
		in jiffies. An RCU-tasks stall warning starts wtih the line:

		INFO: rcu_tasks detected stalls on tasks:

		And continues with the output of sched_show_task() for each
		task stalling the current RCU-tasks grace period.

		For non-RCU-tasks flavors of RCU, when a CPU detects that it is stalling,
		it will print a message similar to the following:

		INFO: rcu_sched_state detected stall on CPU 5 (t=2500 jiffies)

		@@ -174,8 +186,12 @@ o A CPU looping with preemption disabled. This condition can
		o A CPU looping with bottom halves disabled. This condition can
		result in RCU-sched and RCU-bh stalls.

		o For !CONFIG_PREEMPT kernels, a CPU looping anywhere in the kernel
		without invoking schedule().
		o For !CONFIG_PREEMPT kernels, a CPU looping anywhere in the
		kernel without invoking schedule(). Note that cond_resched()
		does not necessarily prevent RCU CPU stall warnings. Therefore,
		if the looping in the kernel is really expected and desirable
		behavior, you might need to replace some of the cond_resched()
		calls with calls to cond_resched_rcu_qs().

		o A CPU-bound real-time task in a CONFIG_PREEMPT kernel, which might
		happen to preempt a low-priority task in the middle of an RCU
		@@ -208,11 +224,10 @@ o A hardware failure. This is quite unlikely, but has occurred
		This resulted in a series of RCU CPU stall warnings, eventually
		leading the realization that the CPU had failed.

		The RCU, RCU-sched, and RCU-bh implementations have CPU stall warning.
		SRCU does not have its own CPU stall warnings, but its calls to
		synchronize_sched() will result in RCU-sched detecting RCU-sched-related
		CPU stalls. Please note that RCU only detects CPU stalls when there is
		a grace period in progress. No grace period, no CPU stall warnings.
		The RCU, RCU-sched, RCU-bh, and RCU-tasks implementations have CPU stall
		warning. Note that SRCU does -not- have CPU stall warnings. Please note
		that RCU only detects CPU stalls when there is a grace period in progress.
		No grace period, no CPU stall warnings.

		To diagnose the cause of the stall, inspect the stack traces.
		The offending function will usually be near the top of the stack.

Documentation/kernel-parameters.txt

+5 −0

Original line number	Diff line number	Diff line
		@@ -3000,6 +3000,11 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
		rcupdate.rcu_cpu_stall_timeout= [KNL]
		Set timeout for RCU CPU stall warning messages.

		rcupdate.rcu_task_stall_timeout= [KNL]
		Set timeout in jiffies for RCU task stall warning
		messages. Disable with a value less than or equal
		to zero.

		rdinit= [KNL]
		Format: <full_path>
		Run specified binary instead of /init from the ramdisk,

fs/file.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -367,7 +367,7 @@ static struct fdtable close_files(struct files_struct files)
		struct file * file = xchg(&fdt->fd[i], NULL);
		if (file) {
		filp_close(file, files);
		cond_resched();
		cond_resched_rcu_qs();
		}
		}
		i++;

include/linux/init_task.h

+11 −1

Original line number	Diff line number	Diff line
		@@ -111,12 +111,21 @@ extern struct group_info init_groups;
		#ifdef CONFIG_PREEMPT_RCU
		#define INIT_TASK_RCU_PREEMPT(tsk) \
		.rcu_read_lock_nesting = 0, \
		.rcu_read_unlock_special = 0, \
		.rcu_read_unlock_special.s = 0, \
		.rcu_node_entry = LIST_HEAD_INIT(tsk.rcu_node_entry), \
		INIT_TASK_RCU_TREE_PREEMPT()
		#else
		#define INIT_TASK_RCU_PREEMPT(tsk)
		#endif
		#ifdef CONFIG_TASKS_RCU
		#define INIT_TASK_RCU_TASKS(tsk) \
		.rcu_tasks_holdout = false, \
		.rcu_tasks_holdout_list = \
		LIST_HEAD_INIT(tsk.rcu_tasks_holdout_list), \
		.rcu_tasks_idle_cpu = -1,
		#else
		#define INIT_TASK_RCU_TASKS(tsk)
		#endif

		extern struct cred init_cred;

		@@ -224,6 +233,7 @@ extern struct task_group root_task_group;
		INIT_FTRACE_GRAPH \
		INIT_TRACE_RECURSION \
		INIT_TASK_RCU_PREEMPT(tsk) \
		INIT_TASK_RCU_TASKS(tsk) \
		INIT_CPUSET_SEQ(tsk) \
		INIT_RT_MUTEXES(tsk) \
		INIT_VTIME(tsk) \

include/linux/rcupdate.h

+55 −2

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@ enum rcutorture_type {
		RCU_FLAVOR,
		RCU_BH_FLAVOR,
		RCU_SCHED_FLAVOR,
		RCU_TASKS_FLAVOR,
		SRCU_FLAVOR,
		INVALID_RCU_FLAVOR
		};
		@@ -197,6 +198,28 @@ void call_rcu_sched(struct rcu_head *head,

		void synchronize_sched(void);

		/**
		* call_rcu_tasks() - Queue an RCU for invocation task-based grace period
		* @head: structure to be used for queueing the RCU updates.
		* @func: actual callback function to be invoked after the grace period
		*
		* The callback function will be invoked some time after a full grace
		* period elapses, in other words after all currently executing RCU
		* read-side critical sections have completed. call_rcu_tasks() assumes
		* that the read-side critical sections end at a voluntary context
		* switch (not a preemption!), entry into idle, or transition to usermode
		* execution. As such, there are no read-side primitives analogous to
		* rcu_read_lock() and rcu_read_unlock() because this primitive is intended
		* to determine that all tasks have passed through a safe state, not so
		* much for data-strcuture synchronization.
		*
		* See the description of call_rcu() for more detailed information on
		* memory ordering guarantees.
		*/
		void call_rcu_tasks(struct rcu_head head, void (func)(struct rcu_head *head));
		void synchronize_rcu_tasks(void);
		void rcu_barrier_tasks(void);

		#ifdef CONFIG_PREEMPT_RCU

		void __rcu_read_lock(void);
		@@ -238,8 +261,8 @@ static inline int rcu_preempt_depth(void)

		/* Internal to kernel */
		void rcu_init(void);
		void rcu_sched_qs(int cpu);
		void rcu_bh_qs(int cpu);
		void rcu_sched_qs(void);
		void rcu_bh_qs(void);
		void rcu_check_callbacks(int cpu, int user);
		struct notifier_block;
		void rcu_idle_enter(void);
		@@ -302,6 +325,36 @@ static inline void rcu_init_nohz(void)
		rcu_irq_exit(); \
		} while (0)

		/*
		* Note a voluntary context switch for RCU-tasks benefit. This is a
		* macro rather than an inline function to avoid #include hell.
		*/
		#ifdef CONFIG_TASKS_RCU
		#define TASKS_RCU(x) x
		extern struct srcu_struct tasks_rcu_exit_srcu;
		#define rcu_note_voluntary_context_switch(t) \
		do { \
		if (ACCESS_ONCE((t)->rcu_tasks_holdout)) \
		ACCESS_ONCE((t)->rcu_tasks_holdout) = false; \
		} while (0)
		#else /* #ifdef CONFIG_TASKS_RCU */
		#define TASKS_RCU(x) do { } while (0)
		#define rcu_note_voluntary_context_switch(t) do { } while (0)
		#endif /* #else #ifdef CONFIG_TASKS_RCU */

		/**
		* cond_resched_rcu_qs - Report potential quiescent states to RCU
		*
		* This macro resembles cond_resched(), except that it is defined to
		* report potential quiescent states to RCU-tasks even if the cond_resched()
		* machinery were to be shut off, as some advocate for PREEMPT kernels.
		*/
		#define cond_resched_rcu_qs() \
		do { \
		rcu_note_voluntary_context_switch(current); \
		cond_resched(); \
		} while (0)

		#if defined(CONFIG_DEBUG_LOCK_ALLOC) \|\| defined(CONFIG_RCU_TRACE) \|\| defined(CONFIG_SMP)
		bool __rcu_is_watching(void);
		#endif /* #if defined(CONFIG_DEBUG_LOCK_ALLOC) \|\| defined(CONFIG_RCU_TRACE) \|\| defined(CONFIG_SMP) */

Admin message