Branch data Line data Source code
1 : : /* rwsem-spinlock.c: R/W semaphores: contention handling functions for
2 : : * generic spinlock implementation
3 : : *
4 : : * Copyright (c) 2001 David Howells (dhowells@redhat.com).
5 : : * - Derived partially from idea by Andrea Arcangeli <andrea@suse.de>
6 : : * - Derived also from comments by Linus
7 : : */
8 : : #include <linux/rwsem.h>
9 : : #include <linux/sched.h>
10 : : #include <linux/export.h>
11 : :
12 : : enum rwsem_waiter_type {
13 : : RWSEM_WAITING_FOR_WRITE,
14 : : RWSEM_WAITING_FOR_READ
15 : : };
16 : :
17 : : struct rwsem_waiter {
18 : : struct list_head list;
19 : : struct task_struct *task;
20 : : enum rwsem_waiter_type type;
21 : : };
22 : :
23 : 0 : int rwsem_is_locked(struct rw_semaphore *sem)
24 : : {
25 : : int ret = 1;
26 : : unsigned long flags;
27 : :
28 [ + + ][ - + ]: 13405648 : if (raw_spin_trylock_irqsave(&sem->wait_lock, flags)) {
[ + + ]
29 : 13405057 : ret = (sem->activity != 0);
30 : 13405057 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
31 : : }
32 : 13405353 : return ret;
33 : : }
34 : : EXPORT_SYMBOL(rwsem_is_locked);
35 : :
36 : : /*
37 : : * initialise the semaphore
38 : : */
39 : 0 : void __init_rwsem(struct rw_semaphore *sem, const char *name,
40 : : struct lock_class_key *key)
41 : : {
42 : : #ifdef CONFIG_DEBUG_LOCK_ALLOC
43 : : /*
44 : : * Make sure we are not reinitializing a held semaphore:
45 : : */
46 : : debug_check_no_locks_freed((void *)sem, sizeof(*sem));
47 : : lockdep_init_map(&sem->dep_map, name, key, 0);
48 : : #endif
49 : 2850744 : sem->activity = 0;
50 : 2850744 : raw_spin_lock_init(&sem->wait_lock);
51 : 2850744 : INIT_LIST_HEAD(&sem->wait_list);
52 : 2850744 : }
53 : : EXPORT_SYMBOL(__init_rwsem);
54 : :
55 : : /*
56 : : * handle the lock release when processes blocked on it that can now run
57 : : * - if we come here, then:
58 : : * - the 'active count' _reached_ zero
59 : : * - the 'waiting count' is non-zero
60 : : * - the spinlock must be held by the caller
61 : : * - woken process blocks are discarded from the list after having task zeroed
62 : : * - writers are only woken if wakewrite is non-zero
63 : : */
64 : : static inline struct rw_semaphore *
65 : : __rwsem_do_wake(struct rw_semaphore *sem, int wakewrite)
66 : : {
67 : : struct rwsem_waiter *waiter;
68 : : struct task_struct *tsk;
69 : : int woken;
70 : :
71 : : waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
72 : :
73 [ # # ][ + + ]: 268048 : if (waiter->type == RWSEM_WAITING_FOR_WRITE) {
74 : : if (wakewrite)
75 : : /* Wake up a writer. Note that we do not grant it the
76 : : * lock - it will have to acquire it when it runs. */
77 : 268048 : wake_up_process(waiter->task);
78 : : goto out;
79 : : }
80 : :
81 : : /* grant an infinite number of read locks to the front of the queue */
82 : : woken = 0;
83 : : do {
84 : 125664 : struct list_head *next = waiter->list.next;
85 : :
86 : : list_del(&waiter->list);
87 : 125664 : tsk = waiter->task;
88 : 125664 : smp_mb();
89 : 125664 : waiter->task = NULL;
90 : 125664 : wake_up_process(tsk);
91 : : put_task_struct(tsk);
92 : 125664 : woken++;
93 [ # # ][ + + ]: 125664 : if (next == &sem->wait_list)
94 : : break;
95 : : waiter = list_entry(next, struct rwsem_waiter, list);
96 [ # # ][ + + ]: 30127 : } while (waiter->type != RWSEM_WAITING_FOR_WRITE);
97 : :
98 : 102816 : sem->activity += woken;
99 : :
100 : : out:
101 : : return sem;
102 : : }
103 : :
104 : : /*
105 : : * wake a single writer
106 : : */
107 : : static inline struct rw_semaphore *
108 : : __rwsem_wake_one_writer(struct rw_semaphore *sem)
109 : : {
110 : : struct rwsem_waiter *waiter;
111 : :
112 : : waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
113 : 59769 : wake_up_process(waiter->task);
114 : :
115 : : return sem;
116 : : }
117 : :
118 : : /*
119 : : * get a read lock on the semaphore
120 : : */
121 : 0 : void __sched __down_read(struct rw_semaphore *sem)
122 : : {
123 : : struct rwsem_waiter waiter;
124 : : struct task_struct *tsk;
125 : : unsigned long flags;
126 : :
127 : 8315571 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
128 : :
129 [ + + ][ + + ]: 8315670 : if (sem->activity >= 0 && list_empty(&sem->wait_list)) {
130 : : /* granted */
131 : 8190016 : sem->activity++;
132 : 8190016 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
133 : 8190033 : goto out;
134 : : }
135 : :
136 : 125654 : tsk = current;
137 : 125654 : set_task_state(tsk, TASK_UNINTERRUPTIBLE);
138 : :
139 : : /* set up my own style of waitqueue */
140 : 125664 : waiter.task = tsk;
141 : 125664 : waiter.type = RWSEM_WAITING_FOR_READ;
142 : 125664 : get_task_struct(tsk);
143 : :
144 : 125664 : list_add_tail(&waiter.list, &sem->wait_list);
145 : :
146 : : /* we don't need to touch the semaphore struct anymore */
147 : 125664 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
148 : :
149 : : /* wait to be given the lock */
150 : : for (;;) {
151 [ + + ]: 8566877 : if (!waiter.task)
152 : : break;
153 : 125649 : schedule();
154 : 125644 : set_task_state(tsk, TASK_UNINTERRUPTIBLE);
155 : 125639 : }
156 : :
157 : 125657 : tsk->state = TASK_RUNNING;
158 : : out:
159 : : ;
160 : 8315690 : }
161 : :
162 : : /*
163 : : * trylock for reading -- returns 1 if successful, 0 if contention
164 : : */
165 : 0 : int __down_read_trylock(struct rw_semaphore *sem)
166 : : {
167 : : unsigned long flags;
168 : : int ret = 0;
169 : :
170 : :
171 : 103044372 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
172 : :
173 [ + + ][ + + ]: 103071674 : if (sem->activity >= 0 && list_empty(&sem->wait_list)) {
174 : : /* granted */
175 : 102943042 : sem->activity++;
176 : : ret = 1;
177 : : }
178 : :
179 : 103071674 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
180 : :
181 : 103073936 : return ret;
182 : : }
183 : :
184 : : /*
185 : : * get a write lock on the semaphore
186 : : */
187 : 0 : void __sched __down_write_nested(struct rw_semaphore *sem, int subclass)
188 : : {
189 : : struct rwsem_waiter waiter;
190 : : struct task_struct *tsk;
191 : : unsigned long flags;
192 : :
193 : 52843940 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
194 : :
195 : : /* set up my own style of waitqueue */
196 : 52845208 : tsk = current;
197 : 52845208 : waiter.task = tsk;
198 : 52845208 : waiter.type = RWSEM_WAITING_FOR_WRITE;
199 : 52845208 : list_add_tail(&waiter.list, &sem->wait_list);
200 : :
201 : : /* wait for someone to release the lock */
202 : : for (;;) {
203 : : /*
204 : : * That is the key to support write lock stealing: allows the
205 : : * task already on CPU to get the lock soon rather than put
206 : : * itself into sleep and waiting for system woke it or someone
207 : : * else in the head of the wait list up.
208 : : */
209 [ + + ]: 52932784 : if (sem->activity == 0)
210 : : break;
211 : 87576 : set_task_state(tsk, TASK_UNINTERRUPTIBLE);
212 : 87576 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
213 : 87576 : schedule();
214 : 87576 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
215 : 87576 : }
216 : : /* got the lock */
217 : 52845208 : sem->activity = -1;
218 : : list_del(&waiter.list);
219 : :
220 : 52845208 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
221 : 52846835 : }
222 : :
223 : 0 : void __sched __down_write(struct rw_semaphore *sem)
224 : : {
225 : 52840282 : __down_write_nested(sem, 0);
226 : 52846890 : }
227 : :
228 : : /*
229 : : * trylock for writing -- returns 1 if successful, 0 if contention
230 : : */
231 : 0 : int __down_write_trylock(struct rw_semaphore *sem)
232 : : {
233 : : unsigned long flags;
234 : : int ret = 0;
235 : :
236 : 0 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
237 : :
238 [ # # ]: 0 : if (sem->activity == 0) {
239 : : /* got the lock */
240 : 0 : sem->activity = -1;
241 : : ret = 1;
242 : : }
243 : :
244 : 0 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
245 : :
246 : 0 : return ret;
247 : : }
248 : :
249 : : /*
250 : : * release a read lock on the semaphore
251 : : */
252 : 0 : void __up_read(struct rw_semaphore *sem)
253 : : {
254 : : unsigned long flags;
255 : :
256 : 111212319 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
257 : :
258 [ + + ][ + + ]: 111253068 : if (--sem->activity == 0 && !list_empty(&sem->wait_list))
259 : : sem = __rwsem_wake_one_writer(sem);
260 : :
261 : 111253068 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
262 : 111252564 : }
263 : :
264 : : /*
265 : : * release a write lock on the semaphore
266 : : */
267 : 0 : void __up_write(struct rw_semaphore *sem)
268 : : {
269 : : unsigned long flags;
270 : :
271 : 52844675 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
272 : :
273 : 52845786 : sem->activity = 0;
274 [ + + ]: 52845786 : if (!list_empty(&sem->wait_list))
275 : : sem = __rwsem_do_wake(sem, 1);
276 : :
277 : 52845787 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
278 : 52845668 : }
279 : :
280 : : /*
281 : : * downgrade a write lock into a read lock
282 : : * - just wake up any readers at the front of the queue
283 : : */
284 : 0 : void __downgrade_write(struct rw_semaphore *sem)
285 : : {
286 : : unsigned long flags;
287 : :
288 : 0 : raw_spin_lock_irqsave(&sem->wait_lock, flags);
289 : :
290 : 0 : sem->activity = 1;
291 [ # # ]: 0 : if (!list_empty(&sem->wait_list))
292 : : sem = __rwsem_do_wake(sem, 0);
293 : :
294 : 0 : raw_spin_unlock_irqrestore(&sem->wait_lock, flags);
295 : 0 : }
296 : :
|
