]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - include/linux/mcs_spinlock.h
e9a4d74c63dc90364227128fec365183d31c5914
4 * This file contains the main data structure and API definitions of MCS lock.
6 * The MCS lock (proposed by Mellor-Crummey and Scott) is a simple spin-lock
7 * with the desirable properties of being fair, and with each cpu trying
8 * to acquire the lock spinning on a local variable.
9 * It avoids expensive cache bouncings that common test-and-set spin-lock
10 * implementations incur.
12 #ifndef __LINUX_MCS_SPINLOCK_H
13 #define __LINUX_MCS_SPINLOCK_H
16 struct mcs_spinlock
*next
;
17 int locked
; /* 1 if lock acquired */
20 #ifndef arch_mcs_spin_lock_contended
22 * Using smp_load_acquire() provides a memory barrier that ensures
23 * subsequent operations happen after the lock is acquired.
25 #define arch_mcs_spin_lock_contended(l) \
27 while (!(smp_load_acquire(l))) \
28 arch_mutex_cpu_relax(); \
32 #ifndef arch_mcs_spin_unlock_contended
34 * smp_store_release() provides a memory barrier to ensure all
35 * operations in the critical section has been completed before
38 #define arch_mcs_spin_unlock_contended(l) \
39 smp_store_release((l), 1)
43 * Note: the smp_load_acquire/smp_store_release pair is not
44 * sufficient to form a full memory barrier across
45 * cpus for many architectures (except x86) for mcs_unlock and mcs_lock.
46 * For applications that need a full barrier across multiple cpus
47 * with mcs_unlock and mcs_lock pair, smp_mb__after_unlock_lock() should be
48 * used after mcs_lock.
52 * In order to acquire the lock, the caller should declare a local node and
53 * pass a reference of the node to this function in addition to the lock.
54 * If the lock has already been acquired, then this will proceed to spin
55 * on this node->locked until the previous lock holder sets the node->locked
56 * in mcs_spin_unlock().
58 * We don't inline mcs_spin_lock() so that perf can correctly account for the
59 * time spent in this lock function.
62 void mcs_spin_lock(struct mcs_spinlock
**lock
, struct mcs_spinlock
*node
)
64 struct mcs_spinlock
*prev
;
70 prev
= xchg(lock
, node
);
71 if (likely(prev
== NULL
)) {
73 * Lock acquired, don't need to set node->locked to 1. Threads
74 * only spin on its own node->locked value for lock acquisition.
75 * However, since this thread can immediately acquire the lock
76 * and does not proceed to spin on its own node->locked, this
77 * value won't be used. If a debug mode is needed to
78 * audit lock status, then set node->locked value here.
82 ACCESS_ONCE(prev
->next
) = node
;
84 /* Wait until the lock holder passes the lock down. */
85 arch_mcs_spin_lock_contended(&node
->locked
);
89 * Releases the lock. The caller should pass in the corresponding node that
90 * was used to acquire the lock.
93 void mcs_spin_unlock(struct mcs_spinlock
**lock
, struct mcs_spinlock
*node
)
95 struct mcs_spinlock
*next
= ACCESS_ONCE(node
->next
);
99 * Release the lock by setting it to NULL
101 if (likely(cmpxchg(lock
, node
, NULL
) == node
))
103 /* Wait until the next pointer is set */
104 while (!(next
= ACCESS_ONCE(node
->next
)))
105 arch_mutex_cpu_relax();
108 /* Pass lock to next waiter. */
109 arch_mcs_spin_unlock_contended(&next
->locked
);
112 #endif /* __LINUX_MCS_SPINLOCK_H */