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

The output of "cat rcu/rcu_sched/rcu_pending" looks as follows:

  0!np=26111 qsp=29 rpq=5386 cbr=1 cng=570 gpc=3674 gps=577 nn=15903

  1!np=28913 qsp=35 rpq=6097 cbr=1 cng=448 gpc=3700 gps=554 nn=18113

  2!np=32740 qsp=37 rpq=6202 cbr=0 cng=476 gpc=4627 gps=546 nn=20889

  3 np=23679 qsp=22 rpq=5044 cbr=1 cng=415 gpc=3403 gps=347 nn=14469

  4!np=30714 qsp=4 rpq=5574 cbr=0 cng=528 gpc=3931 gps=639 nn=20042

  5 np=28910 qsp=2 rpq=5246 cbr=0 cng=428 gpc=4105 gps=709 nn=18422

  6!np=38648 qsp=5 rpq=7076 cbr=0 cng=840 gpc=4072 gps=961 nn=25699

  7 np=37275 qsp=2 rpq=6873 cbr=0 cng=868 gpc=3416 gps=971 nn=25147

  0!np=26111 qsp=29 rpq=5386 cbr=1 cng=570 gpc=3674 gps=577 nn=15903 ndw=0

  1!np=28913 qsp=35 rpq=6097 cbr=1 cng=448 gpc=3700 gps=554 nn=18113 ndw=0

  2!np=32740 qsp=37 rpq=6202 cbr=0 cng=476 gpc=4627 gps=546 nn=20889 ndw=0

  3 np=23679 qsp=22 rpq=5044 cbr=1 cng=415 gpc=3403 gps=347 nn=14469 ndw=0

  4!np=30714 qsp=4 rpq=5574 cbr=0 cng=528 gpc=3931 gps=639 nn=20042 ndw=0

  5 np=28910 qsp=2 rpq=5246 cbr=0 cng=428 gpc=4105 gps=709 nn=18422 ndw=0

  6!np=38648 qsp=5 rpq=7076 cbr=0 cng=840 gpc=4072 gps=961 nn=25699 ndw=0

  7 np=37275 qsp=2 rpq=6873 cbr=0 cng=868 gpc=3416 gps=971 nn=25147 ndw=0

The fields are as follows:

o	"gps" is the number of times that a new grace period had started,

	but this CPU was not yet aware of it.

o	"ndw" is the number of times that a wakeup of an rcuo

	callback-offload kthread had to be deferred in order to avoid

	deadlock.

o	"nn" is the number of times that this CPU needed nothing.

    balk: nt=0 egt=6541 bt=0 nb=0 ny=126 nos=0

This information is output only for rcu_preempt.  Each two-line entry

corresponds to a leaf rcu_node strcuture.  The fields are as follows:

corresponds to a leaf rcu_node structure.  The fields are as follows:

o	"n:m" is the CPU-number range for the corresponding two-line

	entry.  In the sample output above, the first entry covers

	spin_lock(&producer_lock);

	unsigned long head = buffer->head;

	/* The spin_unlock() and next spin_lock() provide needed ordering. */

	unsigned long tail = ACCESS_ONCE(buffer->tail);

	if (CIRC_SPACE(head, tail, buffer->size) >= 1) {

		produce_item(item);

		smp_wmb(); /* commit the item before incrementing the head */

		buffer->head = (head + 1) & (buffer->size - 1);

		smp_store_release(buffer->head,

				  (head + 1) & (buffer->size - 1));

		/* wake_up() will make sure that the head is committed before

		 * waking anyone up */

before the head index makes it available to the consumer and then instructs the

CPU that the revised head index must be written before the consumer is woken.

Note that wake_up() doesn't have to be the exact mechanism used, but whatever

is used must guarantee a (write) memory barrier between the update of the head

index and the change of state of the consumer, if a change of state occurs.

Note that wake_up() does not guarantee any sort of barrier unless something

is actually awakened.  We therefore cannot rely on it for ordering.  However,

there is always one element of the array left empty.  Therefore, the

producer must produce two elements before it could possibly corrupt the

element currently being read by the consumer.  Therefore, the unlock-lock

pair between consecutive invocations of the consumer provides the necessary

ordering between the read of the index indicating that the consumer has

vacated a given element and the write by the producer to that same element.

THE CONSUMER

	spin_lock(&consumer_lock);

	unsigned long head = ACCESS_ONCE(buffer->head);

	/* Read index before reading contents at that index. */

	unsigned long head = smp_load_acquire(buffer->head);

	unsigned long tail = buffer->tail;

	if (CIRC_CNT(head, tail, buffer->size) >= 1) {

		/* read index before reading contents at that index */

		smp_read_barrier_depends();

		/* extract one item from the buffer */

		struct item *item = buffer[tail];

		consume_item(item);

		smp_mb(); /* finish reading descriptor before incrementing tail */

		buffer->tail = (tail + 1) & (buffer->size - 1);

		/* Finish reading descriptor before incrementing tail. */

		smp_store_release(buffer->tail,

				  (tail + 1) & (buffer->size - 1));

	}

	spin_unlock(&consumer_lock);

the new item, and then it shall make sure the CPU has finished reading the item

before it writes the new tail pointer, which will erase the item.

Note the use of ACCESS_ONCE() in both algorithms to read the opposition index.

This prevents the compiler from discarding and reloading its cached value -

which some compilers will do across smp_read_barrier_depends().  This isn't

strictly needed if you can be sure that the opposition index will _only_ be

used the once.

Note the use of ACCESS_ONCE() and smp_load_acquire() to read the

opposition index.  This prevents the compiler from discarding and

reloading its cached value - which some compilers will do across

smp_read_barrier_depends().  This isn't strictly needed if you can

be sure that the opposition index will _only_ be used the once.

The smp_load_acquire() additionally forces the CPU to order against

subsequent memory references.  Similarly, smp_store_release() is used

in both algorithms to write the thread's index.  This documents the

fact that we are writing to something that can be read concurrently,

prevents the compiler from tearing the store, and enforces ordering

against previous accesses.

===============

			for RCU-preempt, and "s" for RCU-sched, and "N"

			is the CPU number.  This reduces OS jitter on the

			offloaded CPUs, which can be useful for HPC and

			real-time workloads.  It can also improve energy

			efficiency for asymmetric multiprocessors.

			periodically wake up to do the polling.

	rcutree.blimit=	[KNL]

			Set maximum number of finished RCU callbacks to process

			in one batch.

			Set maximum number of finished RCU callbacks to

			process in one batch.

	rcutree.rcu_fanout_leaf= [KNL]

			Increase the number of CPUs assigned to each

			value is one, and maximum value is HZ.

	rcutree.qhimark= [KNL]

			Set threshold of queued

			RCU callbacks over which batch limiting is disabled.

			Set threshold of queued RCU callbacks beyond which

			batch limiting is disabled.

	rcutree.qlowmark= [KNL]

			Set threshold of queued RCU callbacks below which

F:	Documentation/RCU/torture.txt

F:	kernel/rcu/torture.c

RCUTORTURE TEST FRAMEWORK

M:	"Paul E. McKenney" <paulmck@linux.vnet.ibm.com>

S:	Supported

T:	git git://git.kernel.org/pub/scm/linux/kernel/git/paulmck/linux-rcu.git

F:	tools/testing/selftests/rcutorture

RDC R-321X SoC

M:	Florian Fainelli <florian@openwrt.org>

S:	Maintained

	}

	if (all) {

		rcu_assign_pointer(bond->curr_active_slave, NULL);

		RCU_INIT_POINTER(bond->curr_active_slave, NULL);

	} else if (oldcurrent == slave) {

		/*

		 * Note that we hold RTNL over this sequence, so there