Merge branches 'cond_resched.2017.12.04a', 'dyntick.2017.11.28a',...

Its fields are as follows:

<pre>

  1   int dynticks_nesting;

  2   int dynticks_nmi_nesting;

  1   long dynticks_nesting;

  2   long dynticks_nmi_nesting;

  3   atomic_t dynticks;

  4   bool rcu_need_heavy_qs;

  5   unsigned long rcu_qs_ctr;

</pre>

<p>The <tt>-&gt;dynticks_nesting</tt> field counts the

nesting depth of normal interrupts.

In addition, this counter is incremented when exiting dyntick-idle

mode and decremented when entering it.

nesting depth of process execution, so that in normal circumstances

this counter has value zero or one.

NMIs, irqs, and tracers are counted by the <tt>-&gt;dynticks_nmi_nesting</tt>

field.

Because NMIs cannot be masked, changes to this variable have to be

undertaken carefully using an algorithm provided by Andy Lutomirski.

The initial transition from idle adds one, and nested transitions

add two, so that a nesting level of five is represented by a

<tt>-&gt;dynticks_nmi_nesting</tt> value of nine.

This counter can therefore be thought of as counting the number

of reasons why this CPU cannot be permitted to enter dyntick-idle

mode, aside from non-maskable interrupts (NMIs).

NMIs are counted by the <tt>-&gt;dynticks_nmi_nesting</tt>

field, except that NMIs that interrupt non-dyntick-idle execution

are not counted.

mode, aside from process-level transitions.

<p>However, it turns out that when running in non-idle kernel context,

the Linux kernel is fully capable of entering interrupt handlers that

never exit and perhaps also vice versa.

Therefore, whenever the <tt>-&gt;dynticks_nesting</tt> field is

incremented up from zero, the <tt>-&gt;dynticks_nmi_nesting</tt> field

is set to a large positive number, and whenever the

<tt>-&gt;dynticks_nesting</tt> field is decremented down to zero,

the the <tt>-&gt;dynticks_nmi_nesting</tt> field is set to zero.

Assuming that the number of misnested interrupts is not sufficient

to overflow the counter, this approach corrects the

<tt>-&gt;dynticks_nmi_nesting</tt> field every time the corresponding

CPU enters the idle loop from process context.

</p><p>The <tt>-&gt;dynticks</tt> field counts the corresponding

CPU's transitions to and from dyntick-idle mode, so that this counter

<tr><th>&nbsp;</th></tr>

<tr><th align="left">Quick Quiz:</th></tr>

<tr><td>

	Why not just count all NMIs?

	Wouldn't that be simpler and less error prone?

	Why not simply combine the <tt>-&gt;dynticks_nesting</tt>

	and <tt>-&gt;dynticks_nmi_nesting</tt> counters into a

	single counter that just counts the number of reasons that

	the corresponding CPU is non-idle?

</td></tr>

<tr><th align="left">Answer:</th></tr>

<tr><td bgcolor="#ffffff"><font color="ffffff">

	It seems simpler only until you think hard about how to go about

	updating the <tt>rcu_dynticks</tt> structure's

	<tt>-&gt;dynticks</tt> field.

	Because this would fail in the presence of interrupts whose

	handlers never return and of handlers that manage to return

	from a made-up interrupt.

</font></td></tr>

<tr><td>&nbsp;</td></tr>

</table>

DYNIX/ptx used an explicit memory barrier for publication, but had nothing

resembling <tt>rcu_dereference()</tt> for subscription, nor did it

have anything resembling the <tt>smp_read_barrier_depends()</tt>

that was later subsumed into <tt>rcu_dereference()</tt>.

that was later subsumed into <tt>rcu_dereference()</tt> and later

still into <tt>READ_ONCE()</tt>.

The need for these operations made itself known quite suddenly at a

late-1990s meeting with the DEC Alpha architects, back in the days when

DEC was still a free-standing company.

		Note that if checks for being within an RCU read-side

		critical section are not required and the pointer is never

		dereferenced, rcu_access_pointer() should be used in place

		of rcu_dereference(). The rcu_access_pointer() primitive

		does not require an enclosing read-side critical section,

		and also omits the smp_read_barrier_depends() included in

		rcu_dereference(), which in turn should provide a small

		performance gain in some CPUs (e.g., the DEC Alpha).

		of rcu_dereference().

	o	The comparison is against a pointer that references memory

		that was initialized "a long time ago."  The reason

	#define rcu_dereference(p) \

	({ \

		typeof(p) _________p1 = p; \

		smp_read_barrier_depends(); \

		typeof(p) _________p1 = READ_ONCE(p); \

		(_________p1); \

	})

			This tests the locking primitive's ability to

			transition abruptly to and from idle.

	locktorture.torture_runnable= [BOOT]

			Start locktorture running at boot time.

	locktorture.torture_type= [KNL]

			Specify the locking implementation to test.

			the same as for rcuperf.nreaders.

			N, where N is the number of CPUs

	rcuperf.perf_runnable= [BOOT]

			Start rcuperf running at boot time.

	rcuperf.perf_type= [KNL]

			Specify the RCU implementation to test.

			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.