blob: 52f23011b6e0f1001eeaa01a6d2f821206cf588b [file] [log] [blame]
Ingo Molnar6053ee32006-01-09 15:59:19 -08001/*
2 * kernel/mutex.c
3 *
4 * Mutexes: blocking mutual exclusion locks
5 *
6 * Started by Ingo Molnar:
7 *
8 * Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
9 *
10 * Many thanks to Arjan van de Ven, Thomas Gleixner, Steven Rostedt and
11 * David Howells for suggestions and improvements.
12 *
Peter Zijlstra0d66bf62009-01-12 14:01:47 +010013 * - Adaptive spinning for mutexes by Peter Zijlstra. (Ported to mainline
14 * from the -rt tree, where it was originally implemented for rtmutexes
15 * by Steven Rostedt, based on work by Gregory Haskins, Peter Morreale
16 * and Sven Dietrich.
17 *
Ingo Molnar6053ee32006-01-09 15:59:19 -080018 * Also see Documentation/mutex-design.txt.
19 */
20#include <linux/mutex.h>
21#include <linux/sched.h>
Clark Williams8bd75c72013-02-07 09:47:07 -060022#include <linux/sched/rt.h>
Paul Gortmaker9984de12011-05-23 14:51:41 -040023#include <linux/export.h>
Ingo Molnar6053ee32006-01-09 15:59:19 -080024#include <linux/spinlock.h>
25#include <linux/interrupt.h>
Ingo Molnar9a11b49a2006-07-03 00:24:33 -070026#include <linux/debug_locks.h>
Ingo Molnar6053ee32006-01-09 15:59:19 -080027
28/*
29 * In the DEBUG case we are using the "NULL fastpath" for mutexes,
30 * which forces all calls into the slowpath:
31 */
32#ifdef CONFIG_DEBUG_MUTEXES
33# include "mutex-debug.h"
34# include <asm-generic/mutex-null.h>
35#else
36# include "mutex.h"
37# include <asm/mutex.h>
38#endif
39
Ingo Molnaref5d4702006-07-03 00:24:55 -070040void
41__mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
Ingo Molnar6053ee32006-01-09 15:59:19 -080042{
43 atomic_set(&lock->count, 1);
44 spin_lock_init(&lock->wait_lock);
45 INIT_LIST_HEAD(&lock->wait_list);
Peter Zijlstra0d66bf62009-01-12 14:01:47 +010046 mutex_clear_owner(lock);
Ingo Molnar6053ee32006-01-09 15:59:19 -080047
Ingo Molnaref5d4702006-07-03 00:24:55 -070048 debug_mutex_init(lock, name, key);
Ingo Molnar6053ee32006-01-09 15:59:19 -080049}
50
51EXPORT_SYMBOL(__mutex_init);
52
Peter Zijlstrae4564f72007-10-11 22:11:12 +020053#ifndef CONFIG_DEBUG_LOCK_ALLOC
Ingo Molnar6053ee32006-01-09 15:59:19 -080054/*
55 * We split the mutex lock/unlock logic into separate fastpath and
56 * slowpath functions, to reduce the register pressure on the fastpath.
57 * We also put the fastpath first in the kernel image, to make sure the
58 * branch is predicted by the CPU as default-untaken.
59 */
Török Edwin7918baa2008-11-24 10:17:42 +020060static __used noinline void __sched
Ingo Molnar9a11b49a2006-07-03 00:24:33 -070061__mutex_lock_slowpath(atomic_t *lock_count);
Ingo Molnar6053ee32006-01-09 15:59:19 -080062
Randy Dunlapef5dc122010-09-02 15:48:16 -070063/**
Ingo Molnar6053ee32006-01-09 15:59:19 -080064 * mutex_lock - acquire the mutex
65 * @lock: the mutex to be acquired
66 *
67 * Lock the mutex exclusively for this task. If the mutex is not
68 * available right now, it will sleep until it can get it.
69 *
70 * The mutex must later on be released by the same task that
71 * acquired it. Recursive locking is not allowed. The task
72 * may not exit without first unlocking the mutex. Also, kernel
73 * memory where the mutex resides mutex must not be freed with
74 * the mutex still locked. The mutex must first be initialized
75 * (or statically defined) before it can be locked. memset()-ing
76 * the mutex to 0 is not allowed.
77 *
78 * ( The CONFIG_DEBUG_MUTEXES .config option turns on debugging
79 * checks that will enforce the restrictions and will also do
80 * deadlock debugging. )
81 *
82 * This function is similar to (but not equivalent to) down().
83 */
H. Peter Anvinb09d2502009-04-01 17:21:56 -070084void __sched mutex_lock(struct mutex *lock)
Ingo Molnar6053ee32006-01-09 15:59:19 -080085{
Ingo Molnarc544bdb2006-01-10 22:10:36 +010086 might_sleep();
Ingo Molnar6053ee32006-01-09 15:59:19 -080087 /*
88 * The locking fastpath is the 1->0 transition from
89 * 'unlocked' into 'locked' state.
Ingo Molnar6053ee32006-01-09 15:59:19 -080090 */
91 __mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);
Peter Zijlstra0d66bf62009-01-12 14:01:47 +010092 mutex_set_owner(lock);
Ingo Molnar6053ee32006-01-09 15:59:19 -080093}
94
95EXPORT_SYMBOL(mutex_lock);
Peter Zijlstrae4564f72007-10-11 22:11:12 +020096#endif
Ingo Molnar6053ee32006-01-09 15:59:19 -080097
Török Edwin7918baa2008-11-24 10:17:42 +020098static __used noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
Ingo Molnar6053ee32006-01-09 15:59:19 -080099
Randy Dunlapef5dc122010-09-02 15:48:16 -0700100/**
Ingo Molnar6053ee32006-01-09 15:59:19 -0800101 * mutex_unlock - release the mutex
102 * @lock: the mutex to be released
103 *
104 * Unlock a mutex that has been locked by this task previously.
105 *
106 * This function must not be used in interrupt context. Unlocking
107 * of a not locked mutex is not allowed.
108 *
109 * This function is similar to (but not equivalent to) up().
110 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800111void __sched mutex_unlock(struct mutex *lock)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800112{
113 /*
114 * The unlocking fastpath is the 0->1 transition from 'locked'
115 * into 'unlocked' state:
Ingo Molnar6053ee32006-01-09 15:59:19 -0800116 */
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100117#ifndef CONFIG_DEBUG_MUTEXES
118 /*
119 * When debugging is enabled we must not clear the owner before time,
120 * the slow path will always be taken, and that clears the owner field
121 * after verifying that it was indeed current.
122 */
123 mutex_clear_owner(lock);
124#endif
Ingo Molnar6053ee32006-01-09 15:59:19 -0800125 __mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);
126}
127
128EXPORT_SYMBOL(mutex_unlock);
129
130/*
131 * Lock a mutex (possibly interruptible), slowpath:
132 */
133static inline int __sched
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200134__mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700135 struct lockdep_map *nest_lock, unsigned long ip)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800136{
137 struct task_struct *task = current;
138 struct mutex_waiter waiter;
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700139 unsigned long flags;
Ingo Molnar6053ee32006-01-09 15:59:19 -0800140
Peter Zijlstra41719b02009-01-14 15:36:26 +0100141 preempt_disable();
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700142 mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);
Frederic Weisbeckerc0226022009-12-02 20:49:16 +0100143
144#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100145 /*
146 * Optimistic spinning.
147 *
148 * We try to spin for acquisition when we find that there are no
149 * pending waiters and the lock owner is currently running on a
150 * (different) CPU.
151 *
152 * The rationale is that if the lock owner is running, it is likely to
153 * release the lock soon.
154 *
155 * Since this needs the lock owner, and this mutex implementation
156 * doesn't track the owner atomically in the lock field, we need to
157 * track it non-atomically.
158 *
159 * We can't do this for DEBUG_MUTEXES because that relies on wait_lock
160 * to serialize everything.
161 */
162
163 for (;;) {
Peter Zijlstrac6eb3dd2011-04-05 17:23:41 +0200164 struct task_struct *owner;
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100165
166 /*
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100167 * If there's an owner, wait for it to either
168 * release the lock or go to sleep.
169 */
170 owner = ACCESS_ONCE(lock->owner);
171 if (owner && !mutex_spin_on_owner(lock, owner))
172 break;
173
Chris Masonac6e60e2009-01-14 17:29:31 +0100174 if (atomic_cmpxchg(&lock->count, 1, 0) == 1) {
175 lock_acquired(&lock->dep_map, ip);
176 mutex_set_owner(lock);
177 preempt_enable();
178 return 0;
179 }
180
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100181 /*
182 * When there's no owner, we might have preempted between the
183 * owner acquiring the lock and setting the owner field. If
184 * we're an RT task that will live-lock because we won't let
185 * the owner complete.
186 */
187 if (!owner && (need_resched() || rt_task(task)))
188 break;
189
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100190 /*
191 * The cpu_relax() call is a compiler barrier which forces
192 * everything in this loop to be re-loaded. We don't need
193 * memory barriers as we'll eventually observe the right
194 * values at the cost of a few extra spins.
195 */
Gerald Schaefer335d7af2010-11-22 15:47:36 +0100196 arch_mutex_cpu_relax();
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100197 }
198#endif
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700199 spin_lock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800200
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700201 debug_mutex_lock_common(lock, &waiter);
Roman Zippelc9f4f062007-05-09 02:35:16 -0700202 debug_mutex_add_waiter(lock, &waiter, task_thread_info(task));
Ingo Molnar6053ee32006-01-09 15:59:19 -0800203
204 /* add waiting tasks to the end of the waitqueue (FIFO): */
205 list_add_tail(&waiter.list, &lock->wait_list);
206 waiter.task = task;
207
Peter Zijlstra93d81d12009-01-14 15:32:51 +0100208 if (atomic_xchg(&lock->count, -1) == 1)
Peter Zijlstra4fe87742007-07-19 01:48:58 -0700209 goto done;
210
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200211 lock_contended(&lock->dep_map, ip);
Peter Zijlstra4fe87742007-07-19 01:48:58 -0700212
Ingo Molnar6053ee32006-01-09 15:59:19 -0800213 for (;;) {
214 /*
215 * Lets try to take the lock again - this is needed even if
216 * we get here for the first time (shortly after failing to
217 * acquire the lock), to make sure that we get a wakeup once
218 * it's unlocked. Later on, if we sleep, this is the
219 * operation that gives us the lock. We xchg it to -1, so
220 * that when we release the lock, we properly wake up the
221 * other waiters:
222 */
Peter Zijlstra93d81d12009-01-14 15:32:51 +0100223 if (atomic_xchg(&lock->count, -1) == 1)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800224 break;
225
226 /*
227 * got a signal? (This code gets eliminated in the
228 * TASK_UNINTERRUPTIBLE case.)
229 */
Oleg Nesterov6ad36762008-06-08 21:20:42 +0400230 if (unlikely(signal_pending_state(state, task))) {
Liam R. Howlettad776532007-12-06 17:37:59 -0500231 mutex_remove_waiter(lock, &waiter,
232 task_thread_info(task));
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200233 mutex_release(&lock->dep_map, 1, ip);
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700234 spin_unlock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800235
236 debug_mutex_free_waiter(&waiter);
Peter Zijlstra41719b02009-01-14 15:36:26 +0100237 preempt_enable();
Ingo Molnar6053ee32006-01-09 15:59:19 -0800238 return -EINTR;
239 }
240 __set_task_state(task, state);
241
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300242 /* didn't get the lock, go to sleep: */
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700243 spin_unlock_mutex(&lock->wait_lock, flags);
Thomas Gleixnerbd2f5532011-03-21 12:33:18 +0100244 schedule_preempt_disabled();
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700245 spin_lock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800246 }
247
Peter Zijlstra4fe87742007-07-19 01:48:58 -0700248done:
Peter Zijlstrac7e78cf2008-10-16 23:17:09 +0200249 lock_acquired(&lock->dep_map, ip);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800250 /* got the lock - rejoice! */
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100251 mutex_remove_waiter(lock, &waiter, current_thread_info());
252 mutex_set_owner(lock);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800253
254 /* set it to 0 if there are no waiters left: */
255 if (likely(list_empty(&lock->wait_list)))
256 atomic_set(&lock->count, 0);
257
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700258 spin_unlock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800259
260 debug_mutex_free_waiter(&waiter);
Peter Zijlstra41719b02009-01-14 15:36:26 +0100261 preempt_enable();
Ingo Molnar6053ee32006-01-09 15:59:19 -0800262
Ingo Molnar6053ee32006-01-09 15:59:19 -0800263 return 0;
264}
265
Ingo Molnaref5d4702006-07-03 00:24:55 -0700266#ifdef CONFIG_DEBUG_LOCK_ALLOC
267void __sched
268mutex_lock_nested(struct mutex *lock, unsigned int subclass)
269{
270 might_sleep();
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700271 __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_);
Ingo Molnaref5d4702006-07-03 00:24:55 -0700272}
273
274EXPORT_SYMBOL_GPL(mutex_lock_nested);
NeilBrownd63a5a72006-12-08 02:36:17 -0800275
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700276void __sched
277_mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest)
278{
279 might_sleep();
280 __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, 0, nest, _RET_IP_);
281}
282
283EXPORT_SYMBOL_GPL(_mutex_lock_nest_lock);
284
NeilBrownd63a5a72006-12-08 02:36:17 -0800285int __sched
Liam R. Howlettad776532007-12-06 17:37:59 -0500286mutex_lock_killable_nested(struct mutex *lock, unsigned int subclass)
287{
288 might_sleep();
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700289 return __mutex_lock_common(lock, TASK_KILLABLE, subclass, NULL, _RET_IP_);
Liam R. Howlettad776532007-12-06 17:37:59 -0500290}
291EXPORT_SYMBOL_GPL(mutex_lock_killable_nested);
292
293int __sched
NeilBrownd63a5a72006-12-08 02:36:17 -0800294mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass)
295{
296 might_sleep();
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100297 return __mutex_lock_common(lock, TASK_INTERRUPTIBLE,
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700298 subclass, NULL, _RET_IP_);
NeilBrownd63a5a72006-12-08 02:36:17 -0800299}
300
301EXPORT_SYMBOL_GPL(mutex_lock_interruptible_nested);
Ingo Molnaref5d4702006-07-03 00:24:55 -0700302#endif
303
Ingo Molnar6053ee32006-01-09 15:59:19 -0800304/*
305 * Release the lock, slowpath:
306 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800307static inline void
Ingo Molnaref5d4702006-07-03 00:24:55 -0700308__mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800309{
Ingo Molnar02706642006-01-10 23:15:02 +0100310 struct mutex *lock = container_of(lock_count, struct mutex, count);
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700311 unsigned long flags;
Ingo Molnar6053ee32006-01-09 15:59:19 -0800312
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700313 spin_lock_mutex(&lock->wait_lock, flags);
Ingo Molnaref5d4702006-07-03 00:24:55 -0700314 mutex_release(&lock->dep_map, nested, _RET_IP_);
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700315 debug_mutex_unlock(lock);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800316
317 /*
318 * some architectures leave the lock unlocked in the fastpath failure
319 * case, others need to leave it locked. In the later case we have to
320 * unlock it here
321 */
322 if (__mutex_slowpath_needs_to_unlock())
323 atomic_set(&lock->count, 1);
324
Ingo Molnar6053ee32006-01-09 15:59:19 -0800325 if (!list_empty(&lock->wait_list)) {
326 /* get the first entry from the wait-list: */
327 struct mutex_waiter *waiter =
328 list_entry(lock->wait_list.next,
329 struct mutex_waiter, list);
330
331 debug_mutex_wake_waiter(lock, waiter);
332
333 wake_up_process(waiter->task);
334 }
335
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700336 spin_unlock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800337}
338
339/*
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700340 * Release the lock, slowpath:
341 */
Török Edwin7918baa2008-11-24 10:17:42 +0200342static __used noinline void
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700343__mutex_unlock_slowpath(atomic_t *lock_count)
344{
Ingo Molnaref5d4702006-07-03 00:24:55 -0700345 __mutex_unlock_common_slowpath(lock_count, 1);
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700346}
347
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200348#ifndef CONFIG_DEBUG_LOCK_ALLOC
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700349/*
Ingo Molnar6053ee32006-01-09 15:59:19 -0800350 * Here come the less common (and hence less performance-critical) APIs:
351 * mutex_lock_interruptible() and mutex_trylock().
352 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800353static noinline int __sched
Liam R. Howlettad776532007-12-06 17:37:59 -0500354__mutex_lock_killable_slowpath(atomic_t *lock_count);
355
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800356static noinline int __sched
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700357__mutex_lock_interruptible_slowpath(atomic_t *lock_count);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800358
Randy Dunlapef5dc122010-09-02 15:48:16 -0700359/**
360 * mutex_lock_interruptible - acquire the mutex, interruptible
Ingo Molnar6053ee32006-01-09 15:59:19 -0800361 * @lock: the mutex to be acquired
362 *
363 * Lock the mutex like mutex_lock(), and return 0 if the mutex has
364 * been acquired or sleep until the mutex becomes available. If a
365 * signal arrives while waiting for the lock then this function
366 * returns -EINTR.
367 *
368 * This function is similar to (but not equivalent to) down_interruptible().
369 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800370int __sched mutex_lock_interruptible(struct mutex *lock)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800371{
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100372 int ret;
373
Ingo Molnarc544bdb2006-01-10 22:10:36 +0100374 might_sleep();
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100375 ret = __mutex_fastpath_lock_retval
Ingo Molnar6053ee32006-01-09 15:59:19 -0800376 (&lock->count, __mutex_lock_interruptible_slowpath);
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100377 if (!ret)
378 mutex_set_owner(lock);
379
380 return ret;
Ingo Molnar6053ee32006-01-09 15:59:19 -0800381}
382
383EXPORT_SYMBOL(mutex_lock_interruptible);
384
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800385int __sched mutex_lock_killable(struct mutex *lock)
Liam R. Howlettad776532007-12-06 17:37:59 -0500386{
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100387 int ret;
388
Liam R. Howlettad776532007-12-06 17:37:59 -0500389 might_sleep();
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100390 ret = __mutex_fastpath_lock_retval
Liam R. Howlettad776532007-12-06 17:37:59 -0500391 (&lock->count, __mutex_lock_killable_slowpath);
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100392 if (!ret)
393 mutex_set_owner(lock);
394
395 return ret;
Liam R. Howlettad776532007-12-06 17:37:59 -0500396}
397EXPORT_SYMBOL(mutex_lock_killable);
398
Török Edwin7918baa2008-11-24 10:17:42 +0200399static __used noinline void __sched
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200400__mutex_lock_slowpath(atomic_t *lock_count)
401{
402 struct mutex *lock = container_of(lock_count, struct mutex, count);
403
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700404 __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, 0, NULL, _RET_IP_);
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200405}
406
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800407static noinline int __sched
Liam R. Howlettad776532007-12-06 17:37:59 -0500408__mutex_lock_killable_slowpath(atomic_t *lock_count)
409{
410 struct mutex *lock = container_of(lock_count, struct mutex, count);
411
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700412 return __mutex_lock_common(lock, TASK_KILLABLE, 0, NULL, _RET_IP_);
Liam R. Howlettad776532007-12-06 17:37:59 -0500413}
414
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800415static noinline int __sched
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700416__mutex_lock_interruptible_slowpath(atomic_t *lock_count)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800417{
418 struct mutex *lock = container_of(lock_count, struct mutex, count);
419
Peter Zijlstrae4c70a62011-05-24 17:12:03 -0700420 return __mutex_lock_common(lock, TASK_INTERRUPTIBLE, 0, NULL, _RET_IP_);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800421}
Peter Zijlstrae4564f72007-10-11 22:11:12 +0200422#endif
Ingo Molnar6053ee32006-01-09 15:59:19 -0800423
424/*
425 * Spinlock based trylock, we take the spinlock and check whether we
426 * can get the lock:
427 */
428static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
429{
430 struct mutex *lock = container_of(lock_count, struct mutex, count);
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700431 unsigned long flags;
Ingo Molnar6053ee32006-01-09 15:59:19 -0800432 int prev;
433
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700434 spin_lock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800435
436 prev = atomic_xchg(&lock->count, -1);
Ingo Molnaref5d4702006-07-03 00:24:55 -0700437 if (likely(prev == 1)) {
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100438 mutex_set_owner(lock);
Ingo Molnaref5d4702006-07-03 00:24:55 -0700439 mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);
440 }
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100441
Ingo Molnar6053ee32006-01-09 15:59:19 -0800442 /* Set it back to 0 if there are no waiters: */
443 if (likely(list_empty(&lock->wait_list)))
444 atomic_set(&lock->count, 0);
445
Ingo Molnar1fb00c62006-06-26 00:24:31 -0700446 spin_unlock_mutex(&lock->wait_lock, flags);
Ingo Molnar6053ee32006-01-09 15:59:19 -0800447
448 return prev == 1;
449}
450
Randy Dunlapef5dc122010-09-02 15:48:16 -0700451/**
452 * mutex_trylock - try to acquire the mutex, without waiting
Ingo Molnar6053ee32006-01-09 15:59:19 -0800453 * @lock: the mutex to be acquired
454 *
455 * Try to acquire the mutex atomically. Returns 1 if the mutex
456 * has been acquired successfully, and 0 on contention.
457 *
458 * NOTE: this function follows the spin_trylock() convention, so
Randy Dunlapef5dc122010-09-02 15:48:16 -0700459 * it is negated from the down_trylock() return values! Be careful
Ingo Molnar6053ee32006-01-09 15:59:19 -0800460 * about this when converting semaphore users to mutexes.
461 *
462 * This function must not be used in interrupt context. The
463 * mutex must be released by the same task that acquired it.
464 */
Harvey Harrison7ad5b3a2008-02-08 04:19:53 -0800465int __sched mutex_trylock(struct mutex *lock)
Ingo Molnar6053ee32006-01-09 15:59:19 -0800466{
Peter Zijlstra0d66bf62009-01-12 14:01:47 +0100467 int ret;
468
469 ret = __mutex_fastpath_trylock(&lock->count, __mutex_trylock_slowpath);
470 if (ret)
471 mutex_set_owner(lock);
472
473 return ret;
Ingo Molnar6053ee32006-01-09 15:59:19 -0800474}
Ingo Molnar6053ee32006-01-09 15:59:19 -0800475EXPORT_SYMBOL(mutex_trylock);
Andrew Mortona511e3f2009-04-29 15:59:58 -0700476
477/**
478 * atomic_dec_and_mutex_lock - return holding mutex if we dec to 0
479 * @cnt: the atomic which we are to dec
480 * @lock: the mutex to return holding if we dec to 0
481 *
482 * return true and hold lock if we dec to 0, return false otherwise
483 */
484int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)
485{
486 /* dec if we can't possibly hit 0 */
487 if (atomic_add_unless(cnt, -1, 1))
488 return 0;
489 /* we might hit 0, so take the lock */
490 mutex_lock(lock);
491 if (!atomic_dec_and_test(cnt)) {
492 /* when we actually did the dec, we didn't hit 0 */
493 mutex_unlock(lock);
494 return 0;
495 }
496 /* we hit 0, and we hold the lock */
497 return 1;
498}
499EXPORT_SYMBOL(atomic_dec_and_mutex_lock);