1 /* rwsem-spinlock.c: R/W semaphores: contention handling functions for
2 * generic spinlock implementation
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
8 #include <linux/rwsem.h>
9 #include <linux/sched.h>
10 #include <linux/module.h>
13 struct list_head list;
14 struct task_struct *task;
16 #define RWSEM_WAITING_FOR_READ 0x00000001
17 #define RWSEM_WAITING_FOR_WRITE 0x00000002
20 int rwsem_is_locked(struct rw_semaphore *sem)
25 if (spin_trylock_irqsave(&sem->wait_lock, flags)) {
26 ret = (sem->activity != 0);
27 spin_unlock_irqrestore(&sem->wait_lock, flags);
31 EXPORT_SYMBOL(rwsem_is_locked);
34 * initialise the semaphore
36 void __init_rwsem(struct rw_semaphore *sem, const char *name,
37 struct lock_class_key *key)
39 #ifdef CONFIG_DEBUG_LOCK_ALLOC
41 * Make sure we are not reinitializing a held semaphore:
43 debug_check_no_locks_freed((void *)sem, sizeof(*sem));
44 lockdep_init_map(&sem->dep_map, name, key, 0);
47 spin_lock_init(&sem->wait_lock);
48 INIT_LIST_HEAD(&sem->wait_list);
50 EXPORT_SYMBOL(__init_rwsem);
53 * handle the lock release when processes blocked on it that can now run
54 * - if we come here, then:
55 * - the 'active count' _reached_ zero
56 * - the 'waiting count' is non-zero
57 * - the spinlock must be held by the caller
58 * - woken process blocks are discarded from the list after having task zeroed
59 * - writers are only woken if wakewrite is non-zero
61 static inline struct rw_semaphore *
62 __rwsem_do_wake(struct rw_semaphore *sem, int wakewrite)
64 struct rwsem_waiter *waiter;
65 struct task_struct *tsk;
68 waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
71 if (waiter->flags & RWSEM_WAITING_FOR_WRITE)
73 goto dont_wake_writers;
76 /* if we are allowed to wake writers try to grant a single write lock
77 * if there's a writer at the front of the queue
78 * - we leave the 'waiting count' incremented to signify potential
81 if (waiter->flags & RWSEM_WAITING_FOR_WRITE) {
83 list_del(&waiter->list);
85 /* Don't touch waiter after ->task has been NULLed */
93 /* grant an infinite number of read locks to the front of the queue */
96 while (waiter->flags & RWSEM_WAITING_FOR_READ) {
97 struct list_head *next = waiter->list.next;
99 list_del(&waiter->list);
103 wake_up_process(tsk);
104 put_task_struct(tsk);
106 if (list_empty(&sem->wait_list))
108 waiter = list_entry(next, struct rwsem_waiter, list);
111 sem->activity += woken;
118 * wake a single writer
120 static inline struct rw_semaphore *
121 __rwsem_wake_one_writer(struct rw_semaphore *sem)
123 struct rwsem_waiter *waiter;
124 struct task_struct *tsk;
128 waiter = list_entry(sem->wait_list.next, struct rwsem_waiter, list);
129 list_del(&waiter->list);
134 wake_up_process(tsk);
135 put_task_struct(tsk);
140 * get a read lock on the semaphore
142 void __sched __down_read(struct rw_semaphore *sem)
144 struct rwsem_waiter waiter;
145 struct task_struct *tsk;
147 spin_lock_irq(&sem->wait_lock);
149 if (sem->activity >= 0 && list_empty(&sem->wait_list)) {
152 spin_unlock_irq(&sem->wait_lock);
157 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
159 /* set up my own style of waitqueue */
161 waiter.flags = RWSEM_WAITING_FOR_READ;
162 get_task_struct(tsk);
164 list_add_tail(&waiter.list, &sem->wait_list);
166 /* we don't need to touch the semaphore struct anymore */
167 spin_unlock_irq(&sem->wait_lock);
169 /* wait to be given the lock */
174 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
177 tsk->state = TASK_RUNNING;
183 * trylock for reading -- returns 1 if successful, 0 if contention
185 int __down_read_trylock(struct rw_semaphore *sem)
191 spin_lock_irqsave(&sem->wait_lock, flags);
193 if (sem->activity >= 0 && list_empty(&sem->wait_list)) {
199 spin_unlock_irqrestore(&sem->wait_lock, flags);
205 * get a write lock on the semaphore
206 * - we increment the waiting count anyway to indicate an exclusive lock
208 void __sched __down_write_nested(struct rw_semaphore *sem, int subclass)
210 struct rwsem_waiter waiter;
211 struct task_struct *tsk;
213 spin_lock_irq(&sem->wait_lock);
215 if (sem->activity == 0 && list_empty(&sem->wait_list)) {
218 spin_unlock_irq(&sem->wait_lock);
223 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
225 /* set up my own style of waitqueue */
227 waiter.flags = RWSEM_WAITING_FOR_WRITE;
228 get_task_struct(tsk);
230 list_add_tail(&waiter.list, &sem->wait_list);
232 /* we don't need to touch the semaphore struct anymore */
233 spin_unlock_irq(&sem->wait_lock);
235 /* wait to be given the lock */
240 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
243 tsk->state = TASK_RUNNING;
248 void __sched __down_write(struct rw_semaphore *sem)
250 __down_write_nested(sem, 0);
254 * trylock for writing -- returns 1 if successful, 0 if contention
256 int __down_write_trylock(struct rw_semaphore *sem)
261 spin_lock_irqsave(&sem->wait_lock, flags);
263 if (sem->activity == 0 && list_empty(&sem->wait_list)) {
269 spin_unlock_irqrestore(&sem->wait_lock, flags);
275 * release a read lock on the semaphore
277 void __up_read(struct rw_semaphore *sem)
281 spin_lock_irqsave(&sem->wait_lock, flags);
283 if (--sem->activity == 0 && !list_empty(&sem->wait_list))
284 sem = __rwsem_wake_one_writer(sem);
286 spin_unlock_irqrestore(&sem->wait_lock, flags);
290 * release a write lock on the semaphore
292 void __up_write(struct rw_semaphore *sem)
296 spin_lock_irqsave(&sem->wait_lock, flags);
299 if (!list_empty(&sem->wait_list))
300 sem = __rwsem_do_wake(sem, 1);
302 spin_unlock_irqrestore(&sem->wait_lock, flags);
306 * downgrade a write lock into a read lock
307 * - just wake up any readers at the front of the queue
309 void __downgrade_write(struct rw_semaphore *sem)
313 spin_lock_irqsave(&sem->wait_lock, flags);
316 if (!list_empty(&sem->wait_list))
317 sem = __rwsem_do_wake(sem, 0);
319 spin_unlock_irqrestore(&sem->wait_lock, flags);