]>
Commit | Line | Data |
---|---|---|
70af2f8a WL |
1 | /* |
2 | * Queue read/write lock | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation; either version 2 of the License, or | |
7 | * (at your option) any later version. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * (C) Copyright 2013-2014 Hewlett-Packard Development Company, L.P. | |
15 | * | |
16 | * Authors: Waiman Long <waiman.long@hp.com> | |
17 | */ | |
18 | #ifndef __ASM_GENERIC_QRWLOCK_H | |
19 | #define __ASM_GENERIC_QRWLOCK_H | |
20 | ||
21 | #include <linux/atomic.h> | |
22 | #include <asm/barrier.h> | |
23 | #include <asm/processor.h> | |
24 | ||
25 | #include <asm-generic/qrwlock_types.h> | |
26 | ||
27 | /* | |
2db34e8b | 28 | * Writer states & reader shift and bias. |
29 | * | |
30 | * | +0 | +1 | +2 | +3 | | |
31 | * ----+----+----+----+----+ | |
32 | * LE | 78 | 56 | 34 | 12 | 0x12345678 | |
33 | * ----+----+----+----+----+ | |
34 | * | wr | rd | | |
35 | * +----+----+----+----+ | |
36 | * | |
37 | * ----+----+----+----+----+ | |
38 | * BE | 12 | 34 | 56 | 78 | 0x12345678 | |
39 | * ----+----+----+----+----+ | |
40 | * | rd | wr | | |
41 | * +----+----+----+----+ | |
70af2f8a WL |
42 | */ |
43 | #define _QW_WAITING 1 /* A writer is waiting */ | |
44 | #define _QW_LOCKED 0xff /* A writer holds the lock */ | |
45 | #define _QW_WMASK 0xff /* Writer mask */ | |
46 | #define _QR_SHIFT 8 /* Reader count shift */ | |
47 | #define _QR_BIAS (1U << _QR_SHIFT) | |
48 | ||
49 | /* | |
50 | * External function declarations | |
51 | */ | |
0e06e5be | 52 | extern void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts); |
f7d71f20 | 53 | extern void queued_write_lock_slowpath(struct qrwlock *lock); |
70af2f8a | 54 | |
70af2f8a | 55 | /** |
f7d71f20 | 56 | * queued_read_trylock - try to acquire read lock of a queue rwlock |
70af2f8a WL |
57 | * @lock : Pointer to queue rwlock structure |
58 | * Return: 1 if lock acquired, 0 if failed | |
59 | */ | |
f7d71f20 | 60 | static inline int queued_read_trylock(struct qrwlock *lock) |
70af2f8a WL |
61 | { |
62 | u32 cnts; | |
63 | ||
64 | cnts = atomic_read(&lock->cnts); | |
65 | if (likely(!(cnts & _QW_WMASK))) { | |
77e430e3 | 66 | cnts = (u32)atomic_add_return_acquire(_QR_BIAS, &lock->cnts); |
70af2f8a WL |
67 | if (likely(!(cnts & _QW_WMASK))) |
68 | return 1; | |
69 | atomic_sub(_QR_BIAS, &lock->cnts); | |
70 | } | |
71 | return 0; | |
72 | } | |
73 | ||
74 | /** | |
f7d71f20 | 75 | * queued_write_trylock - try to acquire write lock of a queue rwlock |
70af2f8a WL |
76 | * @lock : Pointer to queue rwlock structure |
77 | * Return: 1 if lock acquired, 0 if failed | |
78 | */ | |
f7d71f20 | 79 | static inline int queued_write_trylock(struct qrwlock *lock) |
70af2f8a WL |
80 | { |
81 | u32 cnts; | |
82 | ||
83 | cnts = atomic_read(&lock->cnts); | |
84 | if (unlikely(cnts)) | |
85 | return 0; | |
86 | ||
77e430e3 WD |
87 | return likely(atomic_cmpxchg_acquire(&lock->cnts, |
88 | cnts, cnts | _QW_LOCKED) == cnts); | |
70af2f8a WL |
89 | } |
90 | /** | |
f7d71f20 | 91 | * queued_read_lock - acquire read lock of a queue rwlock |
70af2f8a WL |
92 | * @lock: Pointer to queue rwlock structure |
93 | */ | |
f7d71f20 | 94 | static inline void queued_read_lock(struct qrwlock *lock) |
70af2f8a WL |
95 | { |
96 | u32 cnts; | |
97 | ||
77e430e3 | 98 | cnts = atomic_add_return_acquire(_QR_BIAS, &lock->cnts); |
70af2f8a WL |
99 | if (likely(!(cnts & _QW_WMASK))) |
100 | return; | |
101 | ||
102 | /* The slowpath will decrement the reader count, if necessary. */ | |
0e06e5be | 103 | queued_read_lock_slowpath(lock, cnts); |
70af2f8a WL |
104 | } |
105 | ||
106 | /** | |
f7d71f20 | 107 | * queued_write_lock - acquire write lock of a queue rwlock |
70af2f8a WL |
108 | * @lock : Pointer to queue rwlock structure |
109 | */ | |
f7d71f20 | 110 | static inline void queued_write_lock(struct qrwlock *lock) |
70af2f8a WL |
111 | { |
112 | /* Optimize for the unfair lock case where the fair flag is 0. */ | |
77e430e3 | 113 | if (atomic_cmpxchg_acquire(&lock->cnts, 0, _QW_LOCKED) == 0) |
70af2f8a WL |
114 | return; |
115 | ||
f7d71f20 | 116 | queued_write_lock_slowpath(lock); |
70af2f8a WL |
117 | } |
118 | ||
119 | /** | |
f7d71f20 | 120 | * queued_read_unlock - release read lock of a queue rwlock |
70af2f8a WL |
121 | * @lock : Pointer to queue rwlock structure |
122 | */ | |
f7d71f20 | 123 | static inline void queued_read_unlock(struct qrwlock *lock) |
70af2f8a WL |
124 | { |
125 | /* | |
126 | * Atomically decrement the reader count | |
127 | */ | |
77e430e3 | 128 | (void)atomic_sub_return_release(_QR_BIAS, &lock->cnts); |
70af2f8a WL |
129 | } |
130 | ||
70af2f8a | 131 | /** |
f7d71f20 | 132 | * queued_write_unlock - release write lock of a queue rwlock |
70af2f8a WL |
133 | * @lock : Pointer to queue rwlock structure |
134 | */ | |
f7d71f20 | 135 | static inline void queued_write_unlock(struct qrwlock *lock) |
70af2f8a | 136 | { |
e0d02285 | 137 | smp_store_release(&lock->wmode, 0); |
70af2f8a | 138 | } |
70af2f8a WL |
139 | |
140 | /* | |
141 | * Remapping rwlock architecture specific functions to the corresponding | |
142 | * queue rwlock functions. | |
143 | */ | |
f7d71f20 WL |
144 | #define arch_read_lock(l) queued_read_lock(l) |
145 | #define arch_write_lock(l) queued_write_lock(l) | |
146 | #define arch_read_trylock(l) queued_read_trylock(l) | |
147 | #define arch_write_trylock(l) queued_write_trylock(l) | |
148 | #define arch_read_unlock(l) queued_read_unlock(l) | |
149 | #define arch_write_unlock(l) queued_write_unlock(l) | |
70af2f8a WL |
150 | |
151 | #endif /* __ASM_GENERIC_QRWLOCK_H */ |