WebSVN – Kolibri OS – Diff – /drivers/include/linux/seqlock.h


#ifndef __LINUX_SEQLOCK_H
#define __LINUX_SEQLOCK_H
/*
 * Reader/writer consistent mechanism without starving writers. This type of
 * lock for data where the reader wants a consistent set of information
 * and is willing to retry if the information changes. There are two types
 * of readers:
 * 1. Sequence readers which never block a writer but they may have to retry
 *    if a writer is in progress by detecting change in sequence number.
 *    Writers do not wait for a sequence reader.
 * 2. Locking readers which will wait if a writer or another locking reader
 *    is in progress. A locking reader in progress will also block a writer
 *    from going forward. Unlike the regular rwlock, the read lock here is
 *    exclusive so that only one locking reader can get it.
 *
 * This is not as cache friendly as brlock. Also, this may not work well
 * for data that contains pointers, because any writer could
 * invalidate a pointer that a reader was following.
 *
 * Expected non-blocking reader usage:
 * 	do {
 *	    seq = read_seqbegin(&foo);
 * 	...
 *      } while (read_seqretry(&foo, seq));
 *
 *
 * On non-SMP the spin locks disappear but the writer still needs
 * to increment the sequence variables because an interrupt routine could
 * change the state of the data.
 *
 * Based on x86_64 vsyscall gettimeofday 
 * by Keith Owens and Andrea Arcangeli
 */
 
#include 
#include 
#include 
#include 
#include 
 
/*
 * Version using sequence counter only.
 * This can be used when code has its own mutex protecting the
 * updating starting before the write_seqcountbeqin() and ending
 * after the write_seqcount_end().
 */
typedef struct seqcount {
	unsigned sequence;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
	struct lockdep_map dep_map;
#endif
} seqcount_t;
 
static inline void __seqcount_init(seqcount_t *s, const char *name,
					  struct lock_class_key *key)
{
	/*
	 * Make sure we are not reinitializing a held lock:
	 */
	lockdep_init_map(&s->dep_map, name, key, 0);
	s->sequence = 0;
}
 
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define SEQCOUNT_DEP_MAP_INIT(lockname) \
		.dep_map = { .name = #lockname } \
 
# define seqcount_init(s)				\
	do {						\
		static struct lock_class_key __key;	\
		__seqcount_init((s), #s, &__key);	\
	} while (0)
 
static inline void seqcount_lockdep_reader_access(const seqcount_t *s)
{
	seqcount_t *l = (seqcount_t *)s;
	unsigned long flags;
 
	local_irq_save(flags);
	seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);
	seqcount_release(&l->dep_map, 1, _RET_IP_);
	local_irq_restore(flags);
}
 
#else
# define SEQCOUNT_DEP_MAP_INIT(lockname)
# define seqcount_init(s) __seqcount_init(s, NULL, NULL)
# define seqcount_lockdep_reader_access(x)
#endif
 
#define SEQCNT_ZERO(lockname) { .sequence = 0, SEQCOUNT_DEP_MAP_INIT(lockname)}
 
 
/**
 * __read_seqcount_begin - begin a seq-read critical section (without barrier)
 * @s: pointer to seqcount_t
 * Returns: count to be passed to read_seqcount_retry
 *
 * __read_seqcount_begin is like read_seqcount_begin, but has no smp_rmb()
 * barrier. Callers should ensure that smp_rmb() or equivalent ordering is
 * provided before actually loading any of the variables that are to be
 * protected in this critical section.
 *
 * Use carefully, only in critical code, and comment how the barrier is
 * provided.
 */
static inline unsigned __read_seqcount_begin(const seqcount_t *s)
{
	unsigned ret;
 
repeat:
	ret = READ_ONCE(s->sequence);
	if (unlikely(ret & 1)) {
		cpu_relax();
		goto repeat;
	}
	return ret;
}
 
/**
 * raw_read_seqcount - Read the raw seqcount
 * @s: pointer to seqcount_t
 * Returns: count to be passed to read_seqcount_retry
 *
 * raw_read_seqcount opens a read critical section of the given
 * seqcount without any lockdep checking and without checking or
 * masking the LSB. Calling code is responsible for handling that.
 */
static inline unsigned raw_read_seqcount(const seqcount_t *s)
{
	unsigned ret = READ_ONCE(s->sequence);
	smp_rmb();
	return ret;
}
 
/**
 * raw_read_seqcount_begin - start seq-read critical section w/o lockdep
 * @s: pointer to seqcount_t
 * Returns: count to be passed to read_seqcount_retry
 *
 * raw_read_seqcount_begin opens a read critical section of the given
 * seqcount, but without any lockdep checking. Validity of the critical
 * section is tested by checking read_seqcount_retry function.
 */
static inline unsigned raw_read_seqcount_begin(const seqcount_t *s)
{
	unsigned ret = __read_seqcount_begin(s);
	smp_rmb();
	return ret;
}
 
/**
 * read_seqcount_begin - begin a seq-read critical section
 * @s: pointer to seqcount_t
 * Returns: count to be passed to read_seqcount_retry
 *
 * read_seqcount_begin opens a read critical section of the given seqcount.
 * Validity of the critical section is tested by checking read_seqcount_retry
 * function.
 */
static inline unsigned read_seqcount_begin(const seqcount_t *s)
{
	seqcount_lockdep_reader_access(s);
	return raw_read_seqcount_begin(s);
}
 
/**
 * raw_seqcount_begin - begin a seq-read critical section
 * @s: pointer to seqcount_t
 * Returns: count to be passed to read_seqcount_retry
 *
 * raw_seqcount_begin opens a read critical section of the given seqcount.
 * Validity of the critical section is tested by checking read_seqcount_retry
 * function.
 *
 * Unlike read_seqcount_begin(), this function will not wait for the count
 * to stabilize. If a writer is active when we begin, we will fail the
 * read_seqcount_retry() instead of stabilizing at the beginning of the
 * critical section.
 */
static inline unsigned raw_seqcount_begin(const seqcount_t *s)
{
	unsigned ret = READ_ONCE(s->sequence);
	smp_rmb();
	return ret & ~1;
}
 
/**
 * __read_seqcount_retry - end a seq-read critical section (without barrier)
 * @s: pointer to seqcount_t
 * @start: count, from read_seqcount_begin
 * Returns: 1 if retry is required, else 0
 *
 * __read_seqcount_retry is like read_seqcount_retry, but has no smp_rmb()
 * barrier. Callers should ensure that smp_rmb() or equivalent ordering is
 * provided before actually loading any of the variables that are to be
 * protected in this critical section.
 *
 * Use carefully, only in critical code, and comment how the barrier is
 * provided.
 */
static inline int __read_seqcount_retry(const seqcount_t *s, unsigned start)
{
	return unlikely(s->sequence != start);
}
 
/**
 * read_seqcount_retry - end a seq-read critical section
 * @s: pointer to seqcount_t
 * @start: count, from read_seqcount_begin
 * Returns: 1 if retry is required, else 0
 *
 * read_seqcount_retry closes a read critical section of the given seqcount.
 * If the critical section was invalid, it must be ignored (and typically
 * retried).
 */
static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
{
	smp_rmb();
	return __read_seqcount_retry(s, start);
}
 
 
 
static inline void raw_write_seqcount_begin(seqcount_t *s)
{
	s->sequence++;
	smp_wmb();
}
 
static inline void raw_write_seqcount_end(seqcount_t *s)
{
	smp_wmb();
	s->sequence++;
}
 
/**
 * raw_write_seqcount_barrier - do a seq write barrier
 * @s: pointer to seqcount_t
 *
 * This can be used to provide an ordering guarantee instead of the
 * usual consistency guarantee. It is one wmb cheaper, because we can
 * collapse the two back-to-back wmb()s.
 *
 *      seqcount_t seq;
 *      bool X = true, Y = false;
 *
 *      void read(void)
 *      {
 *              bool x, y;
 *
 *              do {
 *                      int s = read_seqcount_begin(&seq);
 *
 *                      x = X; y = Y;
 *
 *              } while (read_seqcount_retry(&seq, s));
 *
 *              BUG_ON(!x && !y);
 *      }
 *
 *      void write(void)
 *      {
 *              Y = true;
 *
 *              raw_write_seqcount_barrier(seq);
 *
 *              X = false;
 *      }
 */
static inline void raw_write_seqcount_barrier(seqcount_t *s)
{
	s->sequence++;
	smp_wmb();
	s->sequence++;
}
 
static inline int raw_read_seqcount_latch(seqcount_t *s)
{
	return lockless_dereference(s->sequence);
}
 
/**
 * raw_write_seqcount_latch - redirect readers to even/odd copy
 * @s: pointer to seqcount_t
 *
 * The latch technique is a multiversion concurrency control method that allows
 * queries during non-atomic modifications. If you can guarantee queries never
 * interrupt the modification -- e.g. the concurrency is strictly between CPUs
 * -- you most likely do not need this.
 *
 * Where the traditional RCU/lockless data structures rely on atomic
 * modifications to ensure queries observe either the old or the new state the
 * latch allows the same for non-atomic updates. The trade-off is doubling the
 * cost of storage; we have to maintain two copies of the entire data
 * structure.
 *
 * 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:
 *
 * struct latch_struct {
 *	seqcount_t		seq;
 *	struct data_struct	data[2];
 * };
 *
 * Where a modification, which is assumed to be externally serialized, does the
 * following:
 *
 * void latch_modify(struct latch_struct *latch, ...)
 * {
 *	smp_wmb();	<- Ensure that the last data[1] update is visible
 *	latch->seq++;
 *	smp_wmb();	<- Ensure that the seqcount update is visible
 *
 *	modify(latch->data[0], ...);
 *
 *	smp_wmb();	<- Ensure that the data[0] update is visible
 *	latch->seq++;
 *	smp_wmb();	<- Ensure that the seqcount update is visible
 *
 *	modify(latch->data[1], ...);
 * }
 *
 * The query will have a form like:
 *
 * struct entry *latch_query(struct latch_struct *latch, ...)
 * {
 *	struct entry *entry;
 *	unsigned seq, idx;
 *
 *	do {
 *		seq = lockless_dereference(latch->seq);
 *
 *		idx = seq & 0x01;
 *		entry = data_query(latch->data[idx], ...);
 *
 *		smp_rmb();
 *	} while (seq != latch->seq);
 *
 *	return entry;
 * }
 *
 * So during the modification, queries are first redirected to data[1]. Then we
 * 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
 *       the publishing of new entries in the case where data is a dynamic
 *       data structure.
 *
 *       An iteration might start in data[0] and get suspended long enough
 *       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
 *       patterns to manage the lifetimes of the objects within.
 */
static inline void raw_write_seqcount_latch(seqcount_t *s)
{
       smp_wmb();      /* prior stores before incrementing "sequence" */
       s->sequence++;
       smp_wmb();      /* increment "sequence" before following stores */
}
 
/*
 * Sequence counter only version assumes that callers are using their
 * own mutexing.
 */
static inline void write_seqcount_begin_nested(seqcount_t *s, int subclass)
{
	raw_write_seqcount_begin(s);
	seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
}
 
static inline void write_seqcount_begin(seqcount_t *s)
{
	write_seqcount_begin_nested(s, 0);
}
 
static inline void write_seqcount_end(seqcount_t *s)
{
	seqcount_release(&s->dep_map, 1, _RET_IP_);
	raw_write_seqcount_end(s);
}
 
/**
 * write_seqcount_invalidate - invalidate in-progress read-side seq operations
 * @s: pointer to seqcount_t
 *
 * After write_seqcount_invalidate, no read-side seq operations will complete
 * successfully and see data older than this.
 */
static inline void write_seqcount_invalidate(seqcount_t *s)
{
	smp_wmb();
	s->sequence+=2;
}
 
typedef struct {
	struct seqcount seqcount;
	spinlock_t lock;
} seqlock_t;
 
/*
 * These macros triggered gcc-3.x compile-time problems.  We think these are
 * OK now.  Be cautious.
 */
#define __SEQLOCK_UNLOCKED(lockname)			\
	{						\
		.seqcount = SEQCNT_ZERO(lockname),	\
		.lock =	__SPIN_LOCK_UNLOCKED(lockname)	\
	}
 
#define seqlock_init(x)					\
	do {						\
		seqcount_init(&(x)->seqcount);		\
		spin_lock_init(&(x)->lock);		\
	} while (0)
 
#define DEFINE_SEQLOCK(x) \
		seqlock_t x = __SEQLOCK_UNLOCKED(x)
 
/*
 * Read side functions for starting and finalizing a read side section.
 */
static inline unsigned read_seqbegin(const seqlock_t *sl)
{
	return read_seqcount_begin(&sl->seqcount);
}
 
static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start)
{
	return read_seqcount_retry(&sl->seqcount, start);
}
 
/*
 * Lock out other writers and update the count.
 * Acts like a normal spin_lock/unlock.
 * Don't need preempt_disable() because that is in the spin_lock already.
 */
static inline void write_seqlock(seqlock_t *sl)
{
	spin_lock(&sl->lock);
	write_seqcount_begin(&sl->seqcount);
}
 
static inline void write_sequnlock(seqlock_t *sl)
{
	write_seqcount_end(&sl->seqcount);
	spin_unlock(&sl->lock);
}
 
static inline void write_seqlock_bh(seqlock_t *sl)
{
	spin_lock_bh(&sl->lock);
	write_seqcount_begin(&sl->seqcount);
}
 
static inline void write_sequnlock_bh(seqlock_t *sl)
{
	write_seqcount_end(&sl->seqcount);
	spin_unlock_bh(&sl->lock);
}
 
static inline void write_seqlock_irq(seqlock_t *sl)
{
	spin_lock_irq(&sl->lock);
	write_seqcount_begin(&sl->seqcount);
}
 
static inline void write_sequnlock_irq(seqlock_t *sl)
{
	write_seqcount_end(&sl->seqcount);
	spin_unlock_irq(&sl->lock);
}
 
static inline unsigned long __write_seqlock_irqsave(seqlock_t *sl)
{
	unsigned long flags;
 
	spin_lock_irqsave(&sl->lock, flags);
	write_seqcount_begin(&sl->seqcount);
	return flags;
}
 
#define write_seqlock_irqsave(lock, flags)				\
	do { flags = __write_seqlock_irqsave(lock); } while (0)
 
static inline void
write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
{
	write_seqcount_end(&sl->seqcount);
	spin_unlock_irqrestore(&sl->lock, flags);
}
 
/*
 * A locking reader exclusively locks out other writers and locking readers,
 * but doesn't update the sequence number. Acts like a normal spin_lock/unlock.
 * Don't need preempt_disable() because that is in the spin_lock already.
 */
static inline void read_seqlock_excl(seqlock_t *sl)
{
	spin_lock(&sl->lock);
}
 
static inline void read_sequnlock_excl(seqlock_t *sl)
{
	spin_unlock(&sl->lock);
}
 
/**
 * read_seqbegin_or_lock - begin a sequence number check or locking block
 * @lock: sequence lock
 * @seq : sequence number to be checked
 *
 * First try it once optimistically without taking the lock. If that fails,
 * take the lock. The sequence number is also used as a marker for deciding
 * whether to be a reader (even) or writer (odd).
 * N.B. seq must be initialized to an even number to begin with.
 */
static inline void read_seqbegin_or_lock(seqlock_t *lock, int *seq)
{
	if (!(*seq & 1))	/* Even */
		*seq = read_seqbegin(lock);
	else			/* Odd */
		read_seqlock_excl(lock);
}
 
static inline int need_seqretry(seqlock_t *lock, int seq)
{
	return !(seq & 1) && read_seqretry(lock, seq);
}
 
static inline void done_seqretry(seqlock_t *lock, int seq)
{
	if (seq & 1)
		read_sequnlock_excl(lock);
}
 
static inline void read_seqlock_excl_bh(seqlock_t *sl)
{
	spin_lock_bh(&sl->lock);
}
 
static inline void read_sequnlock_excl_bh(seqlock_t *sl)
{
	spin_unlock_bh(&sl->lock);
}
 
static inline void read_seqlock_excl_irq(seqlock_t *sl)
{
	spin_lock_irq(&sl->lock);
}
 
static inline void read_sequnlock_excl_irq(seqlock_t *sl)
{
	spin_unlock_irq(&sl->lock);
}
 
static inline unsigned long __read_seqlock_excl_irqsave(seqlock_t *sl)
{
	unsigned long flags;
 
	spin_lock_irqsave(&sl->lock, flags);
	return flags;
}
 
#define read_seqlock_excl_irqsave(lock, flags)				\
	do { flags = __read_seqlock_excl_irqsave(lock); } while (0)
 
static inline void
read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)
{
	spin_unlock_irqrestore(&sl->lock, flags);
}
 
static inline unsigned long
read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)
{
	unsigned long flags = 0;
 
	if (!(*seq & 1))	/* Even */
		*seq = read_seqbegin(lock);
	else			/* Odd */
		read_seqlock_excl_irqsave(lock, flags);
 
	return flags;
}
 
static inline void
done_seqretry_irqrestore(seqlock_t *lock, int seq, unsigned long flags)
{
	if (seq & 1)
		read_sequnlock_excl_irqrestore(lock, flags);
}
#endif /* __LINUX_SEQLOCK_H */

Rev 6934	Rev 6936
1	#ifndef __LINUX_SEQLOCK_H	1	#ifndef __LINUX_SEQLOCK_H
2	#define __LINUX_SEQLOCK_H	2	#define __LINUX_SEQLOCK_H
3	/*	3	/*
4	* Reader/writer consistent mechanism without starving writers. This type of	4	* Reader/writer consistent mechanism without starving writers. This type of
5	* lock for data where the reader wants a consistent set of information	5	* lock for data where the reader wants a consistent set of information
6	* and is willing to retry if the information changes. There are two types	6	* and is willing to retry if the information changes. There are two types
7	* of readers:	7	* of readers:
8	* 1. Sequence readers which never block a writer but they may have to retry	8	* 1. Sequence readers which never block a writer but they may have to retry
9	* if a writer is in progress by detecting change in sequence number.	9	* if a writer is in progress by detecting change in sequence number.
10	* Writers do not wait for a sequence reader.	10	* Writers do not wait for a sequence reader.
11	* 2. Locking readers which will wait if a writer or another locking reader	11	* 2. Locking readers which will wait if a writer or another locking reader
12	* is in progress. A locking reader in progress will also block a writer	12	* is in progress. A locking reader in progress will also block a writer
13	* from going forward. Unlike the regular rwlock, the read lock here is	13	* from going forward. Unlike the regular rwlock, the read lock here is
14	* exclusive so that only one locking reader can get it.	14	* exclusive so that only one locking reader can get it.
15	*	15	*
16	* This is not as cache friendly as brlock. Also, this may not work well	16	* This is not as cache friendly as brlock. Also, this may not work well
17	* for data that contains pointers, because any writer could	17	* for data that contains pointers, because any writer could
18	* invalidate a pointer that a reader was following.	18	* invalidate a pointer that a reader was following.
19	*	19	*
20	* Expected non-blocking reader usage:	20	* Expected non-blocking reader usage:
21	* do {	21	* do {
22	* seq = read_seqbegin(&foo);	22	* seq = read_seqbegin(&foo);
23	* ...	23	* ...
24	* } while (read_seqretry(&foo, seq));	24	* } while (read_seqretry(&foo, seq));
25	*	25	*
26	*	26	*
27	* On non-SMP the spin locks disappear but the writer still needs	27	* On non-SMP the spin locks disappear but the writer still needs
28	* to increment the sequence variables because an interrupt routine could	28	* to increment the sequence variables because an interrupt routine could
29	* change the state of the data.	29	* change the state of the data.
30	*	30	*
31	* Based on x86_64 vsyscall gettimeofday	31	* Based on x86_64 vsyscall gettimeofday
32	* by Keith Owens and Andrea Arcangeli	32	* by Keith Owens and Andrea Arcangeli
33	*/	33	*/
34		34
35	#include	35	#include
36	#include	36	#include
37	#include	37	#include
38	#include	38	#include
39	#include	39	#include
40		40
41	/*	41	/*
42	* Version using sequence counter only.	42	* Version using sequence counter only.
43	* This can be used when code has its own mutex protecting the	43	* This can be used when code has its own mutex protecting the
44	* updating starting before the write_seqcountbeqin() and ending	44	* updating starting before the write_seqcountbeqin() and ending
45	* after the write_seqcount_end().	45	* after the write_seqcount_end().
46	*/	46	*/
47	typedef struct seqcount {	47	typedef struct seqcount {
48	unsigned sequence;	48	unsigned sequence;
49	#ifdef CONFIG_DEBUG_LOCK_ALLOC	49	#ifdef CONFIG_DEBUG_LOCK_ALLOC
50	struct lockdep_map dep_map;	50	struct lockdep_map dep_map;
51	#endif	51	#endif
52	} seqcount_t;	52	} seqcount_t;
53		53
54	static inline void __seqcount_init(seqcount_t s, const char name,	54	static inline void __seqcount_init(seqcount_t s, const char name,
55	struct lock_class_key *key)	55	struct lock_class_key *key)
56	{	56	{
57	/*	57	/*
58	* Make sure we are not reinitializing a held lock:	58	* Make sure we are not reinitializing a held lock:
59	*/	59	*/
60	lockdep_init_map(&s->dep_map, name, key, 0);	60	lockdep_init_map(&s->dep_map, name, key, 0);
61	s->sequence = 0;	61	s->sequence = 0;
62	}	62	}
63		63
64	#ifdef CONFIG_DEBUG_LOCK_ALLOC	64	#ifdef CONFIG_DEBUG_LOCK_ALLOC
65	# define SEQCOUNT_DEP_MAP_INIT(lockname) \	65	# define SEQCOUNT_DEP_MAP_INIT(lockname) \
66	.dep_map = { .name = #lockname } \	66	.dep_map = { .name = #lockname } \
67		67
68	# define seqcount_init(s) \	68	# define seqcount_init(s) \
69	do { \	69	do { \
70	static struct lock_class_key __key; \	70	static struct lock_class_key __key; \
71	__seqcount_init((s), #s, &__key); \	71	__seqcount_init((s), #s, &__key); \
72	} while (0)	72	} while (0)
73		73
74	static inline void seqcount_lockdep_reader_access(const seqcount_t *s)	74	static inline void seqcount_lockdep_reader_access(const seqcount_t *s)
75	{	75	{
76	seqcount_t l = (seqcount_t )s;	76	seqcount_t l = (seqcount_t )s;
77	unsigned long flags;	77	unsigned long flags;
78		78
79	local_irq_save(flags);	79	local_irq_save(flags);
80	seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);	80	seqcount_acquire_read(&l->dep_map, 0, 0, _RET_IP_);
81	seqcount_release(&l->dep_map, 1, _RET_IP_);	81	seqcount_release(&l->dep_map, 1, _RET_IP_);
82	local_irq_restore(flags);	82	local_irq_restore(flags);
83	}	83	}
84		84
85	#else	85	#else
86	# define SEQCOUNT_DEP_MAP_INIT(lockname)	86	# define SEQCOUNT_DEP_MAP_INIT(lockname)
87	# define seqcount_init(s) __seqcount_init(s, NULL, NULL)	87	# define seqcount_init(s) __seqcount_init(s, NULL, NULL)
88	# define seqcount_lockdep_reader_access(x)	88	# define seqcount_lockdep_reader_access(x)
89	#endif	89	#endif
90		90
91	#define SEQCNT_ZERO(lockname) { .sequence = 0, SEQCOUNT_DEP_MAP_INIT(lockname)}	91	#define SEQCNT_ZERO(lockname) { .sequence = 0, SEQCOUNT_DEP_MAP_INIT(lockname)}
92		92
93		93
94	/**	94	/**
95	* __read_seqcount_begin - begin a seq-read critical section (without barrier)	95	* __read_seqcount_begin - begin a seq-read critical section (without barrier)
96	* @s: pointer to seqcount_t	96	* @s: pointer to seqcount_t
97	* Returns: count to be passed to read_seqcount_retry	97	* Returns: count to be passed to read_seqcount_retry
98	*	98	*
99	* __read_seqcount_begin is like read_seqcount_begin, but has no smp_rmb()	99	* __read_seqcount_begin is like read_seqcount_begin, but has no smp_rmb()
100	* barrier. Callers should ensure that smp_rmb() or equivalent ordering is	100	* barrier. Callers should ensure that smp_rmb() or equivalent ordering is
101	* provided before actually loading any of the variables that are to be	101	* provided before actually loading any of the variables that are to be
102	* protected in this critical section.	102	* protected in this critical section.
103	*	103	*
104	* Use carefully, only in critical code, and comment how the barrier is	104	* Use carefully, only in critical code, and comment how the barrier is
105	* provided.	105	* provided.
106	*/	106	*/
107	static inline unsigned __read_seqcount_begin(const seqcount_t *s)	107	static inline unsigned __read_seqcount_begin(const seqcount_t *s)
108	{	108	{
109	unsigned ret;	109	unsigned ret;
110		110
111	repeat:	111	repeat:
112	ret = READ_ONCE(s->sequence);	112	ret = READ_ONCE(s->sequence);
113	if (unlikely(ret & 1)) {	113	if (unlikely(ret & 1)) {
114	cpu_relax();	114	cpu_relax();
115	goto repeat;	115	goto repeat;
116	}	116	}
117	return ret;	117	return ret;
118	}	118	}
119		119
120	/**	120	/**
121	* raw_read_seqcount - Read the raw seqcount	121	* raw_read_seqcount - Read the raw seqcount
122	* @s: pointer to seqcount_t	122	* @s: pointer to seqcount_t
123	* Returns: count to be passed to read_seqcount_retry	123	* Returns: count to be passed to read_seqcount_retry
124	*	124	*
125	* raw_read_seqcount opens a read critical section of the given	125	* raw_read_seqcount opens a read critical section of the given
126	* seqcount without any lockdep checking and without checking or	126	* seqcount without any lockdep checking and without checking or
127	* masking the LSB. Calling code is responsible for handling that.	127	* masking the LSB. Calling code is responsible for handling that.
128	*/	128	*/
129	static inline unsigned raw_read_seqcount(const seqcount_t *s)	129	static inline unsigned raw_read_seqcount(const seqcount_t *s)
130	{	130	{
131	unsigned ret = READ_ONCE(s->sequence);	131	unsigned ret = READ_ONCE(s->sequence);
132	smp_rmb();	132	smp_rmb();
133	return ret;	133	return ret;
134	}	134	}
135		135
136	/**	136	/**
137	* raw_read_seqcount_begin - start seq-read critical section w/o lockdep	137	* raw_read_seqcount_begin - start seq-read critical section w/o lockdep
138	* @s: pointer to seqcount_t	138	* @s: pointer to seqcount_t
139	* Returns: count to be passed to read_seqcount_retry	139	* Returns: count to be passed to read_seqcount_retry
140	*	140	*
141	* raw_read_seqcount_begin opens a read critical section of the given	141	* raw_read_seqcount_begin opens a read critical section of the given
142	* seqcount, but without any lockdep checking. Validity of the critical	142	* seqcount, but without any lockdep checking. Validity of the critical
143	* section is tested by checking read_seqcount_retry function.	143	* section is tested by checking read_seqcount_retry function.
144	*/	144	*/
145	static inline unsigned raw_read_seqcount_begin(const seqcount_t *s)	145	static inline unsigned raw_read_seqcount_begin(const seqcount_t *s)
146	{	146	{
147	unsigned ret = __read_seqcount_begin(s);	147	unsigned ret = __read_seqcount_begin(s);
148	smp_rmb();	148	smp_rmb();
149	return ret;	149	return ret;
150	}	150	}
151		151
152	/**	152	/**
153	* read_seqcount_begin - begin a seq-read critical section	153	* read_seqcount_begin - begin a seq-read critical section
154	* @s: pointer to seqcount_t	154	* @s: pointer to seqcount_t
155	* Returns: count to be passed to read_seqcount_retry	155	* Returns: count to be passed to read_seqcount_retry
156	*	156	*
157	* read_seqcount_begin opens a read critical section of the given seqcount.	157	* read_seqcount_begin opens a read critical section of the given seqcount.
158	* Validity of the critical section is tested by checking read_seqcount_retry	158	* Validity of the critical section is tested by checking read_seqcount_retry
159	* function.	159	* function.
160	*/	160	*/
161	static inline unsigned read_seqcount_begin(const seqcount_t *s)	161	static inline unsigned read_seqcount_begin(const seqcount_t *s)
162	{	162	{
163	seqcount_lockdep_reader_access(s);	163	seqcount_lockdep_reader_access(s);
164	return raw_read_seqcount_begin(s);	164	return raw_read_seqcount_begin(s);
165	}	165	}
166		166
167	/**	167	/**
168	* raw_seqcount_begin - begin a seq-read critical section	168	* raw_seqcount_begin - begin a seq-read critical section
169	* @s: pointer to seqcount_t	169	* @s: pointer to seqcount_t
170	* Returns: count to be passed to read_seqcount_retry	170	* Returns: count to be passed to read_seqcount_retry
171	*	171	*
172	* raw_seqcount_begin opens a read critical section of the given seqcount.	172	* raw_seqcount_begin opens a read critical section of the given seqcount.
173	* Validity of the critical section is tested by checking read_seqcount_retry	173	* Validity of the critical section is tested by checking read_seqcount_retry
174	* function.	174	* function.
175	*	175	*
176	* Unlike read_seqcount_begin(), this function will not wait for the count	176	* Unlike read_seqcount_begin(), this function will not wait for the count
177	* to stabilize. If a writer is active when we begin, we will fail the	177	* to stabilize. If a writer is active when we begin, we will fail the
178	* read_seqcount_retry() instead of stabilizing at the beginning of the	178	* read_seqcount_retry() instead of stabilizing at the beginning of the
179	* critical section.	179	* critical section.
180	*/	180	*/
181	static inline unsigned raw_seqcount_begin(const seqcount_t *s)	181	static inline unsigned raw_seqcount_begin(const seqcount_t *s)
182	{	182	{
183	unsigned ret = READ_ONCE(s->sequence);	183	unsigned ret = READ_ONCE(s->sequence);
184	smp_rmb();	184	smp_rmb();
185	return ret & ~1;	185	return ret & ~1;
186	}	186	}
187		187
188	/**	188	/**
189	* __read_seqcount_retry - end a seq-read critical section (without barrier)	189	* __read_seqcount_retry - end a seq-read critical section (without barrier)
190	* @s: pointer to seqcount_t	190	* @s: pointer to seqcount_t
191	* @start: count, from read_seqcount_begin	191	* @start: count, from read_seqcount_begin
192	* Returns: 1 if retry is required, else 0	192	* Returns: 1 if retry is required, else 0
193	*	193	*
194	* __read_seqcount_retry is like read_seqcount_retry, but has no smp_rmb()	194	* __read_seqcount_retry is like read_seqcount_retry, but has no smp_rmb()
195	* barrier. Callers should ensure that smp_rmb() or equivalent ordering is	195	* barrier. Callers should ensure that smp_rmb() or equivalent ordering is
196	* provided before actually loading any of the variables that are to be	196	* provided before actually loading any of the variables that are to be
197	* protected in this critical section.	197	* protected in this critical section.
198	*	198	*
199	* Use carefully, only in critical code, and comment how the barrier is	199	* Use carefully, only in critical code, and comment how the barrier is
200	* provided.	200	* provided.
201	*/	201	*/
202	static inline int __read_seqcount_retry(const seqcount_t *s, unsigned start)	202	static inline int __read_seqcount_retry(const seqcount_t *s, unsigned start)
203	{	203	{
204	return unlikely(s->sequence != start);	204	return unlikely(s->sequence != start);
205	}	205	}
206		206
207	/**	207	/**
208	* read_seqcount_retry - end a seq-read critical section	208	* read_seqcount_retry - end a seq-read critical section
209	* @s: pointer to seqcount_t	209	* @s: pointer to seqcount_t
210	* @start: count, from read_seqcount_begin	210	* @start: count, from read_seqcount_begin
211	* Returns: 1 if retry is required, else 0	211	* Returns: 1 if retry is required, else 0
212	*	212	*
213	* read_seqcount_retry closes a read critical section of the given seqcount.	213	* read_seqcount_retry closes a read critical section of the given seqcount.
214	* If the critical section was invalid, it must be ignored (and typically	214	* If the critical section was invalid, it must be ignored (and typically
215	* retried).	215	* retried).
216	*/	216	*/
217	static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)	217	static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
218	{	218	{
219	smp_rmb();	219	smp_rmb();
220	return __read_seqcount_retry(s, start);	220	return __read_seqcount_retry(s, start);
221	}	221	}
222		222
223		223
224		224
225	static inline void raw_write_seqcount_begin(seqcount_t *s)	225	static inline void raw_write_seqcount_begin(seqcount_t *s)
226	{	226	{
227	s->sequence++;	227	s->sequence++;
228	smp_wmb();	228	smp_wmb();
229	}	229	}
230		230
231	static inline void raw_write_seqcount_end(seqcount_t *s)	231	static inline void raw_write_seqcount_end(seqcount_t *s)
232	{	232	{
233	smp_wmb();	233	smp_wmb();
234	s->sequence++;	234	s->sequence++;
235	}	235	}
-		236
-		237	/**
-		238	* raw_write_seqcount_barrier - do a seq write barrier
-		239	* @s: pointer to seqcount_t
-		240	*
-		241	* This can be used to provide an ordering guarantee instead of the
-		242	* usual consistency guarantee. It is one wmb cheaper, because we can
-		243	* collapse the two back-to-back wmb()s.
-		244	*
-		245	* seqcount_t seq;
-		246	* bool X = true, Y = false;
-		247	*
-		248	* void read(void)
-		249	* {
-		250	* bool x, y;
-		251	*
-		252	* do {
-		253	* int s = read_seqcount_begin(&seq);
-		254	*
-		255	* x = X; y = Y;
-		256	*
-		257	* } while (read_seqcount_retry(&seq, s));
-		258	*
-		259	* BUG_ON(!x && !y);
-		260	* }
-		261	*
-		262	* void write(void)
-		263	* {
-		264	* Y = true;
-		265	*
-		266	* raw_write_seqcount_barrier(seq);
-		267	*
-		268	* X = false;
-		269	* }
-		270	*/
-		271	static inline void raw_write_seqcount_barrier(seqcount_t *s)
-		272	{
-		273	s->sequence++;
-		274	smp_wmb();
-		275	s->sequence++;
-		276	}
-		277
-		278	static inline int raw_read_seqcount_latch(seqcount_t *s)
-		279	{
-		280	return lockless_dereference(s->sequence);
-		281	}
236		282
237	/*	283	/**
238	* raw_write_seqcount_latch - redirect readers to even/odd copy	284	* raw_write_seqcount_latch - redirect readers to even/odd copy
239	* @s: pointer to seqcount_t	285	* @s: pointer to seqcount_t
240	*	286	*
241	* The latch technique is a multiversion concurrency control method that allows	287	* The latch technique is a multiversion concurrency control method that allows
242	* queries during non-atomic modifications. If you can guarantee queries never	288	* queries during non-atomic modifications. If you can guarantee queries never
243	* interrupt the modification -- e.g. the concurrency is strictly between CPUs	289	* interrupt the modification -- e.g. the concurrency is strictly between CPUs
244	* -- you most likely do not need this.	290	* -- you most likely do not need this.
245	*	291	*
246	* Where the traditional RCU/lockless data structures rely on atomic	292	* Where the traditional RCU/lockless data structures rely on atomic
247	* modifications to ensure queries observe either the old or the new state the	293	* modifications to ensure queries observe either the old or the new state the
248	* latch allows the same for non-atomic updates. The trade-off is doubling the	294	* latch allows the same for non-atomic updates. The trade-off is doubling the
249	* cost of storage; we have to maintain two copies of the entire data	295	* cost of storage; we have to maintain two copies of the entire data
250	* structure.	296	* structure.
251	*	297	*
252	* Very simply put: we first modify one copy and then the other. This ensures	298	* Very simply put: we first modify one copy and then the other. This ensures
253	* there is always one copy in a stable state, ready to give us an answer.	299	* there is always one copy in a stable state, ready to give us an answer.
254	*	300	*
255	* The basic form is a data structure like:	301	* The basic form is a data structure like:
256	*	302	*
257	* struct latch_struct {	303	* struct latch_struct {
258	* seqcount_t seq;	304	* seqcount_t seq;
259	* struct data_struct data[2];	305	* struct data_struct data[2];
260	* };	306	* };
261	*	307	*
262	* Where a modification, which is assumed to be externally serialized, does the	308	* Where a modification, which is assumed to be externally serialized, does the
263	* following:	309	* following:
264	*	310	*
265	* void latch_modify(struct latch_struct *latch, ...)	311	* void latch_modify(struct latch_struct *latch, ...)
266	* {	312	* {
267	* smp_wmb(); <- Ensure that the last data[1] update is visible	313	* smp_wmb(); <- Ensure that the last data[1] update is visible
268	* latch->seq++;	314	* latch->seq++;
269	* smp_wmb(); <- Ensure that the seqcount update is visible	315	* smp_wmb(); <- Ensure that the seqcount update is visible
270	*	316	*
271	* modify(latch->data[0], ...);	317	* modify(latch->data[0], ...);
272	*	318	*
273	* smp_wmb(); <- Ensure that the data[0] update is visible	319	* smp_wmb(); <- Ensure that the data[0] update is visible
274	* latch->seq++;	320	* latch->seq++;
275	* smp_wmb(); <- Ensure that the seqcount update is visible	321	* smp_wmb(); <- Ensure that the seqcount update is visible
276	*	322	*
277	* modify(latch->data[1], ...);	323	* modify(latch->data[1], ...);
278	* }	324	* }
279	*	325	*
280	* The query will have a form like:	326	* The query will have a form like:
281	*	327	*
282	* struct entry latch_query(struct latch_struct latch, ...)	328	* struct entry latch_query(struct latch_struct latch, ...)
283	* {	329	* {
284	* struct entry *entry;	330	* struct entry *entry;
285	* unsigned seq, idx;	331	* unsigned seq, idx;
286	*	332	*
287	* do {	333	* do {
288	* seq = lockless_dereference(latch->seq);	334	* seq = lockless_dereference(latch->seq);
289	*	335	*
290	* idx = seq & 0x01;	336	* idx = seq & 0x01;
291	* entry = data_query(latch->data[idx], ...);	337	* entry = data_query(latch->data[idx], ...);
292	*	338	*
293	* smp_rmb();	339	* smp_rmb();
294	* } while (seq != latch->seq);	340	* } while (seq != latch->seq);
295	*	341	*
296	* return entry;	342	* return entry;
297	* }	343	* }
298	*	344	*
299	* So during the modification, queries are first redirected to data[1]. Then we	345	* So during the modification, queries are first redirected to data[1]. Then we
300	* modify data[0]. When that is complete, we redirect queries back to data[0]	346	* modify data[0]. When that is complete, we redirect queries back to data[0]
301	* and we can modify data[1].	347	* and we can modify data[1].
302	*	348	*
303	* NOTE: The non-requirement for atomic modifications does _NOT_ include	349	* NOTE: The non-requirement for atomic modifications does _NOT_ include
304	* the publishing of new entries in the case where data is a dynamic	350	* the publishing of new entries in the case where data is a dynamic
305	* data structure.	351	* data structure.
306	*	352	*
307	* An iteration might start in data[0] and get suspended long enough	353	* An iteration might start in data[0] and get suspended long enough
308	* to miss an entire modification sequence, once it resumes it might	354	* to miss an entire modification sequence, once it resumes it might
309	* observe the new entry.	355	* observe the new entry.
310	*	356	*
311	* NOTE: When data is a dynamic data structure; one should use regular RCU	357	* NOTE: When data is a dynamic data structure; one should use regular RCU
312	* patterns to manage the lifetimes of the objects within.	358	* patterns to manage the lifetimes of the objects within.
313	*/	359	*/
314	static inline void raw_write_seqcount_latch(seqcount_t *s)	360	static inline void raw_write_seqcount_latch(seqcount_t *s)
315	{	361	{
316	smp_wmb(); /* prior stores before incrementing "sequence" */	362	smp_wmb(); /* prior stores before incrementing "sequence" */
317	s->sequence++;	363	s->sequence++;
318	smp_wmb(); /* increment "sequence" before following stores */	364	smp_wmb(); /* increment "sequence" before following stores */
319	}	365	}
320		366
321	/*	367	/*
322	* Sequence counter only version assumes that callers are using their	368	* Sequence counter only version assumes that callers are using their
323	* own mutexing.	369	* own mutexing.
324	*/	370	*/
325	static inline void write_seqcount_begin_nested(seqcount_t *s, int subclass)	371	static inline void write_seqcount_begin_nested(seqcount_t *s, int subclass)
326	{	372	{
327	raw_write_seqcount_begin(s);	373	raw_write_seqcount_begin(s);
328	seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);	374	seqcount_acquire(&s->dep_map, subclass, 0, _RET_IP_);
329	}	375	}
330		376
331	static inline void write_seqcount_begin(seqcount_t *s)	377	static inline void write_seqcount_begin(seqcount_t *s)
332	{	378	{
333	write_seqcount_begin_nested(s, 0);	379	write_seqcount_begin_nested(s, 0);
334	}	380	}
335		381
336	static inline void write_seqcount_end(seqcount_t *s)	382	static inline void write_seqcount_end(seqcount_t *s)
337	{	383	{
338	seqcount_release(&s->dep_map, 1, _RET_IP_);	384	seqcount_release(&s->dep_map, 1, _RET_IP_);
339	raw_write_seqcount_end(s);	385	raw_write_seqcount_end(s);
340	}	386	}
341		387
342	/**	388	/**
343	* write_seqcount_invalidate - invalidate in-progress read-side seq operations	389	* write_seqcount_invalidate - invalidate in-progress read-side seq operations
344	* @s: pointer to seqcount_t	390	* @s: pointer to seqcount_t
345	*	391	*
346	* After write_seqcount_invalidate, no read-side seq operations will complete	392	* After write_seqcount_invalidate, no read-side seq operations will complete
347	* successfully and see data older than this.	393	* successfully and see data older than this.
348	*/	394	*/
349	static inline void write_seqcount_invalidate(seqcount_t *s)	395	static inline void write_seqcount_invalidate(seqcount_t *s)
350	{	396	{
351	smp_wmb();	397	smp_wmb();
352	s->sequence+=2;	398	s->sequence+=2;
353	}	399	}
354		400
355	typedef struct {	401	typedef struct {
356	struct seqcount seqcount;	402	struct seqcount seqcount;
357	spinlock_t lock;	403	spinlock_t lock;
358	} seqlock_t;	404	} seqlock_t;
359		405
360	/*	406	/*
361	* These macros triggered gcc-3.x compile-time problems. We think these are	407	* These macros triggered gcc-3.x compile-time problems. We think these are
362	* OK now. Be cautious.	408	* OK now. Be cautious.
363	*/	409	*/
364	#define __SEQLOCK_UNLOCKED(lockname) \	410	#define __SEQLOCK_UNLOCKED(lockname) \
365	{ \	411	{ \
366	.seqcount = SEQCNT_ZERO(lockname), \	412	.seqcount = SEQCNT_ZERO(lockname), \
367	.lock = __SPIN_LOCK_UNLOCKED(lockname) \	413	.lock = __SPIN_LOCK_UNLOCKED(lockname) \
368	}	414	}
369		415
370	#define seqlock_init(x) \	416	#define seqlock_init(x) \
371	do { \	417	do { \
372	seqcount_init(&(x)->seqcount); \	418	seqcount_init(&(x)->seqcount); \
373	spin_lock_init(&(x)->lock); \	419	spin_lock_init(&(x)->lock); \
374	} while (0)	420	} while (0)
375		421
376	#define DEFINE_SEQLOCK(x) \	422	#define DEFINE_SEQLOCK(x) \
377	seqlock_t x = __SEQLOCK_UNLOCKED(x)	423	seqlock_t x = __SEQLOCK_UNLOCKED(x)
378		424
379	/*	425	/*
380	* Read side functions for starting and finalizing a read side section.	426	* Read side functions for starting and finalizing a read side section.
381	*/	427	*/
382	static inline unsigned read_seqbegin(const seqlock_t *sl)	428	static inline unsigned read_seqbegin(const seqlock_t *sl)
383	{	429	{
384	return read_seqcount_begin(&sl->seqcount);	430	return read_seqcount_begin(&sl->seqcount);
385	}	431	}
386		432
387	static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start)	433	static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start)
388	{	434	{
389	return read_seqcount_retry(&sl->seqcount, start);	435	return read_seqcount_retry(&sl->seqcount, start);
390	}	436	}
391		437
392	/*	438	/*
393	* Lock out other writers and update the count.	439	* Lock out other writers and update the count.
394	* Acts like a normal spin_lock/unlock.	440	* Acts like a normal spin_lock/unlock.
395	* Don't need preempt_disable() because that is in the spin_lock already.	441	* Don't need preempt_disable() because that is in the spin_lock already.
396	*/	442	*/
397	static inline void write_seqlock(seqlock_t *sl)	443	static inline void write_seqlock(seqlock_t *sl)
398	{	444	{
399	spin_lock(&sl->lock);	445	spin_lock(&sl->lock);
400	write_seqcount_begin(&sl->seqcount);	446	write_seqcount_begin(&sl->seqcount);
401	}	447	}
402		448
403	static inline void write_sequnlock(seqlock_t *sl)	449	static inline void write_sequnlock(seqlock_t *sl)
404	{	450	{
405	write_seqcount_end(&sl->seqcount);	451	write_seqcount_end(&sl->seqcount);
406	spin_unlock(&sl->lock);	452	spin_unlock(&sl->lock);
407	}	453	}
408		454
409	static inline void write_seqlock_bh(seqlock_t *sl)	455	static inline void write_seqlock_bh(seqlock_t *sl)
410	{	456	{
411	spin_lock_bh(&sl->lock);	457	spin_lock_bh(&sl->lock);
412	write_seqcount_begin(&sl->seqcount);	458	write_seqcount_begin(&sl->seqcount);
413	}	459	}
414		460
415	static inline void write_sequnlock_bh(seqlock_t *sl)	461	static inline void write_sequnlock_bh(seqlock_t *sl)
416	{	462	{
417	write_seqcount_end(&sl->seqcount);	463	write_seqcount_end(&sl->seqcount);
418	spin_unlock_bh(&sl->lock);	464	spin_unlock_bh(&sl->lock);
419	}	465	}
420		466
421	static inline void write_seqlock_irq(seqlock_t *sl)	467	static inline void write_seqlock_irq(seqlock_t *sl)
422	{	468	{
423	spin_lock_irq(&sl->lock);	469	spin_lock_irq(&sl->lock);
424	write_seqcount_begin(&sl->seqcount);	470	write_seqcount_begin(&sl->seqcount);
425	}	471	}
426		472
427	static inline void write_sequnlock_irq(seqlock_t *sl)	473	static inline void write_sequnlock_irq(seqlock_t *sl)
428	{	474	{
429	write_seqcount_end(&sl->seqcount);	475	write_seqcount_end(&sl->seqcount);
430	spin_unlock_irq(&sl->lock);	476	spin_unlock_irq(&sl->lock);
431	}	477	}
432		478
433	static inline unsigned long __write_seqlock_irqsave(seqlock_t *sl)	479	static inline unsigned long __write_seqlock_irqsave(seqlock_t *sl)
434	{	480	{
435	unsigned long flags;	481	unsigned long flags;
436		482
437	spin_lock_irqsave(&sl->lock, flags);	483	spin_lock_irqsave(&sl->lock, flags);
438	write_seqcount_begin(&sl->seqcount);	484	write_seqcount_begin(&sl->seqcount);
439	return flags;	485	return flags;
440	}	486	}
441		487
442	#define write_seqlock_irqsave(lock, flags) \	488	#define write_seqlock_irqsave(lock, flags) \
443	do { flags = __write_seqlock_irqsave(lock); } while (0)	489	do { flags = __write_seqlock_irqsave(lock); } while (0)
444		490
445	static inline void	491	static inline void
446	write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)	492	write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
447	{	493	{
448	write_seqcount_end(&sl->seqcount);	494	write_seqcount_end(&sl->seqcount);
449	spin_unlock_irqrestore(&sl->lock, flags);	495	spin_unlock_irqrestore(&sl->lock, flags);
450	}	496	}
451		497
452	/*	498	/*
453	* A locking reader exclusively locks out other writers and locking readers,	499	* A locking reader exclusively locks out other writers and locking readers,
454	* but doesn't update the sequence number. Acts like a normal spin_lock/unlock.	500	* but doesn't update the sequence number. Acts like a normal spin_lock/unlock.

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/seqlock.h – Rev 6934 → 6936