Merge branch 'core-rcu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

o	Avoid cancellation when using the "+" and "-" infix arithmetic

	operators.  For example, for a given variable "x", avoid

	"(x-x)".  There are similar arithmetic pitfalls from other

	arithmetic operatiors, such as "(x*0)", "(x/(x+1))" or "(x%1)".

	arithmetic operators, such as "(x*0)", "(x/(x+1))" or "(x%1)".

	The compiler is within its rights to substitute zero for all of

	these expressions, so that subsequent accesses no longer depend

	on the rcu_dereference(), again possibly resulting in bugs due

	Stall-warning messages may be enabled and disabled completely via

	/sys/module/rcupdate/parameters/rcu_cpu_stall_suppress.

CONFIG_RCU_CPU_STALL_INFO

	This kernel configuration parameter causes the stall warning to

	print out additional per-CPU diagnostic information, including

	information on scheduling-clock ticks and RCU's idle-CPU tracking.

RCU_STALL_DELAY_DELTA

	Although the lockdep facility is extremely useful, it does add

sort of false positive without resorting to things like stop_machine(),

which is overkill for this sort of problem.

If the CONFIG_RCU_CPU_STALL_INFO kernel configuration parameter is set,

more information is printed with the stall-warning message, for example:

Recent kernels will print a long form of the stall-warning message:

	INFO: rcu_preempt detected stall on CPU

	0: (63959 ticks this GP) idle=241/3fffffffffffffff/0 softirq=82/543

	   (t=65000 jiffies)

In kernels with CONFIG_RCU_FAST_NO_HZ, even more information is

printed:

In kernels with CONFIG_RCU_FAST_NO_HZ, more information is printed:

	INFO: rcu_preempt detected stall on CPU

	0: (64628 ticks this GP) idle=dd5/3fffffffffffffff/0 softirq=82/543 last_accelerate: a345/d342 nonlazy_posted: 25 .D

of the stall and the first message.

Stall Warnings for Expedited Grace Periods

If an expedited grace period detects a stall, it will place a message

like the following in dmesg:

	INFO: rcu_sched detected expedited stalls on CPUs: { 1 2 6 } 26009 jiffies s: 1043

This indicates that CPUs 1, 2, and 6 have failed to respond to a

reschedule IPI, that the expedited grace period has been going on for

26,009 jiffies, and that the expedited grace-period sequence counter is

1043.  The fact that this last value is odd indicates that an expedited

grace period is in flight.

It is entirely possible to see stall warnings from normal and from

expedited grace periods at about the same time from the same run.

What Causes RCU CPU Stall Warnings?

So your kernel printed an RCU CPU stall warning.  The next question is

The output of "cat rcu/rcu_preempt/rcuexp" looks as follows:

s=21872 d=21872 w=0 tf=0 wd1=0 wd2=0 n=0 sc=21872 dt=21872 dl=0 dx=21872

s=21872 wd0=0 wd1=0 wd2=0 wd3=5 n=0 enq=0 sc=21872

These fields are as follows:

o	"s" is the starting sequence number.

o	"s" is the sequence number, with an odd number indicating that

	an expedited grace period is in progress.

o	"d" is the ending sequence number.  When the starting and ending

	numbers differ, there is an expedited grace period in progress.

o	"w" is the number of times that the sequence numbers have been

	in danger of wrapping.

o	"tf" is the number of times that contention has resulted in a

	failure to begin an expedited grace period.

o	"wd1" and "wd2" are the number of times that an attempt to

	start an expedited grace period found that someone else had

	completed an expedited grace period that satisfies the

o	"wd0", "wd1", "wd2", and "wd3" are the number of times that an

	attempt to start an expedited grace period found that someone

	else had completed an expedited grace period that satisfies the

	attempted request.  "Our work is done."

o	"n" is number of times that contention was so great that

	the request was demoted from an expedited grace period to

	a normal grace period.

o	"n" is number of times that a concurrent CPU-hotplug operation

	forced a fallback to a normal grace period.

o	"enq" is the number of quiescent states still outstanding.

o	"sc" is the number of times that the attempt to start a

	new expedited grace period succeeded.

o	"dt" is the number of times that we attempted to update

	the "d" counter.

o	"dl" is the number of times that we failed to update the "d"

	counter.

o	"dx" is the number of times that we succeeded in updating

	the "d" counter.

The output of "cat rcu/rcu_preempt/rcugp" looks as follows:

	rcu_access_pointer

	rcu_dereference_raw

	rcu_lockdep_assert

	RCU_LOCKDEP_WARN

	rcu_sleep_check

	RCU_NONIDLE

			in a given burst of a callback-flood test.

	rcutorture.fqs_duration= [KNL]

			Set duration of force_quiescent_state bursts.

			Set duration of force_quiescent_state bursts

			in microseconds.

	rcutorture.fqs_holdoff= [KNL]

			Set holdoff time within force_quiescent_state bursts.

			Set holdoff time within force_quiescent_state bursts

			in microseconds.

	rcutorture.fqs_stutter= [KNL]

			Set wait time between force_quiescent_state bursts.

			Set wait time between force_quiescent_state bursts

			in seconds.

	rcutorture.gp_cond= [KNL]

			Use conditional/asynchronous update-side

			primitives, if available.

	rcutorture.gp_exp= [KNL]

			Use expedited update-side primitives.

			Use expedited update-side primitives, if available.

	rcutorture.gp_normal= [KNL]

			Use normal (non-expedited) update-side primitives.

			If both gp_exp and gp_normal are set, do both.

			If neither gp_exp nor gp_normal are set, still

			do both.

			Use normal (non-expedited) asynchronous

			update-side primitives, if available.

	rcutorture.gp_sync= [KNL]

			Use normal (non-expedited) synchronous

			update-side primitives, if available.  If all

			of rcutorture.gp_cond=, rcutorture.gp_exp=,

			rcutorture.gp_normal=, and rcutorture.gp_sync=

			are zero, rcutorture acts as if is interpreted

			they are all non-zero.

	rcutorture.n_barrier_cbs= [KNL]

			Set callbacks/threads for rcu_barrier() testing.

			Set time (s) between CPU-hotplug operations, or

			zero to disable CPU-hotplug testing.

	rcutorture.torture_runnable= [BOOT]

			Start rcutorture running at boot time.

	rcutorture.shuffle_interval= [KNL]

			Set task-shuffle interval (s).  Shuffling tasks

			allows some CPUs to go into dyntick-idle mode

			Test RCU's dyntick-idle handling.  See also the

			rcutorture.shuffle_interval parameter.

	rcutorture.torture_runnable= [BOOT]

			Start rcutorture running at boot time.

	rcutorture.torture_type= [KNL]

			Specify the RCU implementation to test.