[PATCH] add an RCU version of list splicing

	}

}

/**

 * list_splice_init_rcu - splice an RCU-protected list into an existing list.

 * @list:	the RCU-protected list to splice

 * @head:	the place in the list to splice the first list into

 * @sync:	function to sync: synchronize_rcu(), synchronize_sched(), ...

 *

 * @head can be RCU-read traversed concurrently with this function.

 *

 * Note that this function blocks.

 *

 * Important note: the caller must take whatever action is necessary to

 *	prevent any other updates to @head.  In principle, it is possible

 *	to modify the list as soon as sync() begins execution.

 *	If this sort of thing becomes necessary, an alternative version

 *	based on call_rcu() could be created.  But only if -really-

 *	needed -- there is no shortage of RCU API members.

 */

static inline void list_splice_init_rcu(struct list_head *list,

					struct list_head *head,

					void (*sync)(void))

{

	struct list_head *first = list->next;

	struct list_head *last = list->prev;

	struct list_head *at = head->next;

	if (list_empty(head))

		return;

	/* "first" and "last" tracking list, so initialize it. */

	INIT_LIST_HEAD(list);

	/*

	 * At this point, the list body still points to the source list.

	 * Wait for any readers to finish using the list before splicing

	 * the list body into the new list.  Any new readers will see

	 * an empty list.

	 */

	sync();

	/*

	 * Readers are finished with the source list, so perform splice.

	 * The order is important if the new list is global and accessible

	 * to concurrent RCU readers.  Note that RCU readers are not

	 * permitted to traverse the prev pointers without excluding

	 * this function.

	 */

	last->next = at;

	smp_wmb();

	head->next = first;

	first->prev = head;

	at->prev = last;

}

/**

 * list_entry - get the struct for this entry

 * @ptr:	the &struct list_head pointer.