Merge branches 'doc.2017.01.15b', 'dyntick.2017.01.23a', 'fixes.2017.01.23a',...

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

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

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

These fields are as follows:

	completed an expedited grace period that satisfies the attempted

	request.  "Our work is done."

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

/*

 * Lock-less NULL terminated single linked list

 *

 * If there are multiple producers and multiple consumers, llist_add

 * can be used in producers and llist_del_all can be used in

 * consumers.  They can work simultaneously without lock.  But

 * llist_del_first can not be used here.  Because llist_del_first

 * depends on list->first->next does not changed if list->first is not

 * changed during its operation, but llist_del_first, llist_add,

 * llist_add (or llist_del_all, llist_add, llist_add) sequence in

 * another consumer may violate that.

 *

 * If there are multiple producers and one consumer, llist_add can be

 * used in producers and llist_del_all or llist_del_first can be used

 * in the consumer.

 *

 * This can be summarized as follow:

 * Cases where locking is not needed:

 * If there are multiple producers and multiple consumers, llist_add can be

 * used in producers and llist_del_all can be used in consumers simultaneously

 * without locking. Also a single consumer can use llist_del_first while

 * multiple producers simultaneously use llist_add, without any locking.

 *

 * Cases where locking is needed:

 * If we have multiple consumers with llist_del_first used in one consumer, and

 * llist_del_first or llist_del_all used in other consumers, then a lock is

 * needed.  This is because llist_del_first depends on list->first->next not

 * changing, but without lock protection, there's no way to be sure about that

 * if a preemption happens in the middle of the delete operation and on being

 * preempted back, the list->first is the same as before causing the cmpxchg in

 * llist_del_first to succeed. For example, while a llist_del_first operation

 * is in progress in one consumer, then a llist_del_first, llist_add,

 * llist_add (or llist_del_all, llist_add, llist_add) sequence in another

 * consumer may cause violations.

 *

 * This can be summarized as follows:

 *

 *           |   add    | del_first |  del_all

 * add       |    -     |     -     |     -

 * del_first |          |     L     |     L

 * del_all   |          |           |     -

 *

 * Where "-" stands for no lock is needed, while "L" stands for lock

 * is needed.

 * Where, a particular row's operation can happen concurrently with a column's

 * operation, with "-" being no lock needed, while "L" being lock is needed.

 *

 * The list entries deleted via llist_del_all can be traversed with

 * traversing function such as llist_for_each etc.  But the list

		ftrace_dump(oops_dump_mode); \

} while (0)

/*

 * Place this after a lock-acquisition primitive to guarantee that

 * an UNLOCK+LOCK pair acts as a full barrier.  This guarantee applies

 * if the UNLOCK and LOCK are executed by the same CPU or if the

 * UNLOCK and LOCK operate on the same lock variable.

 */

#ifdef CONFIG_PPC

#define smp_mb__after_unlock_lock()	smp_mb()  /* Full ordering for lock. */

#else /* #ifdef CONFIG_PPC */

#define smp_mb__after_unlock_lock()	do { } while (0)

#endif /* #else #ifdef CONFIG_PPC */

#endif /* __LINUX_RCUPDATE_H */

#include <linux/cache.h>

struct rcu_dynticks;

static inline int rcu_dynticks_snap(struct rcu_dynticks *rdtp)

{

	return 0;

}

static inline unsigned long get_state_synchronize_rcu(void)

{

	return 0;

#include <linux/rcupdate.h>

#include <linux/workqueue.h>

struct srcu_struct_array {

	unsigned long c[2];

	unsigned long seq[2];

struct srcu_array {

	unsigned long lock_count[2];

	unsigned long unlock_count[2];

};

struct rcu_batch {

struct srcu_struct {

	unsigned long completed;

	struct srcu_struct_array __percpu *per_cpu_ref;

	struct srcu_array __percpu *per_cpu_ref;

	spinlock_t queue_lock; /* protect ->batch_queue, ->running */

	bool running;

	/* callbacks just queued */

 * See include/linux/percpu-defs.h for the rules on per-CPU variables.

 */

#define __DEFINE_SRCU(name, is_static)					\

	static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\

	static DEFINE_PER_CPU(struct srcu_array, name##_srcu_array);\

	is_static struct srcu_struct name = __SRCU_STRUCT_INIT(name)

#define DEFINE_SRCU(name)		__DEFINE_SRCU(name, /* not static */)

#define DEFINE_STATIC_SRCU(name)	__DEFINE_SRCU(name, static)