seqlock: Properly format kernel-doc code samples

 * atomically, avoiding compiler optimizations; b) to document which writes are

 * meant to propagate to the reader critical section. This is necessary because

 * neither writes before and after the barrier are enclosed in a seq-writer

 * critical section that would ensure readers are aware of ongoing writes.

 * critical section that would ensure readers are aware of ongoing writes::

 *

 *	seqcount_t seq;

 *	bool X = true, Y = false;

 * Very simply put: we first modify one copy and then the other. This ensures

 * there is always one copy in a stable state, ready to give us an answer.

 *

 * The basic form is a data structure like:

 * The basic form is a data structure like::

 *

 *	struct latch_struct {

 *		seqcount_t		seq;

 *	};

 *

 * Where a modification, which is assumed to be externally serialized, does the

 * following:

 * following::

 *

 *	void latch_modify(struct latch_struct *latch, ...)

 *	{

 *	smp_wmb();	<- Ensure that the last data[1] update is visible

 *		smp_wmb();	// Ensure that the last data[1] update is visible

 *		latch->seq++;

 *	smp_wmb();	<- Ensure that the seqcount update is visible

 *		smp_wmb();	// Ensure that the seqcount update is visible

 *

 *		modify(latch->data[0], ...);

 *

 *	smp_wmb();	<- Ensure that the data[0] update is visible

 *		smp_wmb();	// Ensure that the data[0] update is visible

 *		latch->seq++;

 *	smp_wmb();	<- Ensure that the seqcount update is visible

 *		smp_wmb();	// Ensure that the seqcount update is visible

 *

 *		modify(latch->data[1], ...);

 *	}

 *

 * The query will have a form like:

 * The query will have a form like::

 *

 *	struct entry *latch_query(struct latch_struct *latch, ...)

 *	{

 * modify data[0]. When that is complete, we redirect queries back to data[0]

 * and we can modify data[1].

 *

 * NOTE: The non-requirement for atomic modifications does _NOT_ include

 * NOTE:

 *

 *	The non-requirement for atomic modifications does _NOT_ include

 *	the publishing of new entries in the case where data is a dynamic

 *	data structure.

 *

 *	to miss an entire modification sequence, once it resumes it might

 *	observe the new entry.

 *

 * NOTE: When data is a dynamic data structure; one should use regular RCU

 * NOTE:

 *

 *	When data is a dynamic data structure; one should use regular RCU

 *	patterns to manage the lifetimes of the objects within.

 */

static inline void raw_write_seqcount_latch(seqcount_t *s)