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

Pull RCU updates from Ingo Molnar:
 "These are the main changes in this cycle:

    - Streamline RCU's use of per-CPU variables, shifting from "cpu"
      arguments to functions to "this_"-style per-CPU variable
      accessors.

    - signal-handling RCU updates.

    - real-time updates.

    - torture-test updates.

    - miscellaneous fixes.

    - documentation updates"

* 'core-rcu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (34 commits)
  rcu: Fix FIXME in rcu_tasks_kthread()
  rcu: More info about potential deadlocks with rcu_read_unlock()
  rcu: Optimize cond_resched_rcu_qs()
  rcu: Add sparse check for RCU_INIT_POINTER()
  documentation: memory-barriers.txt: Correct example for reorderings
  documentation: Add atomic_long_t to atomic_ops.txt
  documentation: Additional restriction for control dependencies
  documentation: Document RCU self test boot params
  rcutorture: Fix rcu_torture_cbflood() memory leak
  rcutorture: Remove obsolete kversion param in kvm.sh
  rcutorture: Remove stale test configurations
  rcutorture: Enable RCU self test in configs
  rcutorture: Add early boot self tests
  torture: Run Linux-kernel binary out of results directory
  cpu: Avoid puts_pending overflow
  rcu: Remove "cpu" argument to rcu_cleanup_after_idle()
  rcu: Remove "cpu" argument to rcu_prepare_for_idle()
  rcu: Remove "cpu" argument to rcu_needs_cpu()
  rcu: Remove "cpu" argument to rcu_note_context_switch()
  rcu: Remove "cpu" argument to rcu_preempt_check_callbacks()
  ...

1 files changed, 29 insertions, 11 deletions

diff --git a/Documentation/memory-barriers.txt b/Documentation/memory-barriers.txt
index 4af4cea8cff0..7ee2ae6d5451 100644
--- a/Documentation/memory-barriers.txt
+++ b/Documentation/memory-barriers.txt
@@ -121,22 +121,22 @@ For example, consider the following sequence of events:
 The set of accesses as seen by the memory system in the middle can be arranged
 in 24 different combinations:
 
-        STORE A=3,      STORE B=4,      x=LOAD A->3,    y=LOAD B->4
-        STORE A=3,      STORE B=4,      y=LOAD B->4,    x=LOAD A->3
-        STORE A=3,      x=LOAD A->3,    STORE B=4,      y=LOAD B->4
-        STORE A=3,      x=LOAD A->3,    y=LOAD B->2,    STORE B=4
-        STORE A=3,      y=LOAD B->2,    STORE B=4,      x=LOAD A->3
-        STORE A=3,      y=LOAD B->2,    x=LOAD A->3,    STORE B=4
-        STORE B=4,      STORE A=3,      x=LOAD A->3,    y=LOAD B->4
+        STORE A=3,      STORE B=4,      y=LOAD A->3,    x=LOAD B->4
+        STORE A=3,      STORE B=4,      x=LOAD B->4,    y=LOAD A->3
+        STORE A=3,      y=LOAD A->3,    STORE B=4,      x=LOAD B->4
+        STORE A=3,      y=LOAD A->3,    x=LOAD B->2,    STORE B=4
+        STORE A=3,      x=LOAD B->2,    STORE B=4,      y=LOAD A->3
+        STORE A=3,      x=LOAD B->2,    y=LOAD A->3,    STORE B=4
+        STORE B=4,      STORE A=3,      y=LOAD A->3,    x=LOAD B->4
         STORE B=4, ...
         ...
 
 and can thus result in four different combinations of values:
 
-        x == 1, y == 2
-        x == 1, y == 4
-        x == 3, y == 2
-        x == 3, y == 4
+        x == 2, y == 1
+        x == 2, y == 3
+        x == 4, y == 1
+        x == 4, y == 3
 
 
 Furthermore, the stores committed by a CPU to the memory system may not be
@@ -694,6 +694,24 @@ Please note once again that the stores to 'b' differ.  If they were
 identical, as noted earlier, the compiler could pull this store outside
 of the 'if' statement.
 
+You must also be careful not to rely too much on boolean short-circuit
+evaluation.  Consider this example:
+
+        q = ACCESS_ONCE(a);
+        if (a || 1 > 0)
+                ACCESS_ONCE(b) = 1;
+
+Because the second condition is always true, the compiler can transform
+this example as following, defeating control dependency:
+
+        q = ACCESS_ONCE(a);
+        ACCESS_ONCE(b) = 1;
+
+This example underscores the need to ensure that the compiler cannot
+out-guess your code.  More generally, although ACCESS_ONCE() does force
+the compiler to actually emit code for a given load, it does not force
+the compiler to use the results.
+
 Finally, control dependencies do -not- provide transitivity.  This is
 demonstrated by two related examples, with the initial values of
 x and y both being zero: