Lines Matching full:lock
40 __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key) in __mutex_init() argument
42 atomic_long_set(&lock->owner, 0); in __mutex_init()
43 spin_lock_init(&lock->wait_lock); in __mutex_init()
44 INIT_LIST_HEAD(&lock->wait_list); in __mutex_init()
46 osq_lock_init(&lock->osq); in __mutex_init()
49 debug_mutex_init(lock, name, key); in __mutex_init()
54 * @owner: contains: 'struct task_struct *' to the current lock owner,
59 * Bit1 indicates unlock needs to hand the lock to the top-waiter
73 static inline struct task_struct *__mutex_owner(struct mutex *lock) in __mutex_owner() argument
75 return (struct task_struct *)(atomic_long_read(&lock->owner) & ~MUTEX_FLAGS); in __mutex_owner()
83 bool mutex_is_locked(struct mutex *lock) in mutex_is_locked() argument
85 return __mutex_owner(lock) != NULL; in mutex_is_locked()
90 mutex_trylock_recursive(struct mutex *lock) in mutex_trylock_recursive() argument
92 if (unlikely(__mutex_owner(lock) == current)) in mutex_trylock_recursive()
95 return mutex_trylock(lock); in mutex_trylock_recursive()
107 static inline struct task_struct *__mutex_trylock_or_owner(struct mutex *lock) in __mutex_trylock_or_owner() argument
111 owner = atomic_long_read(&lock->owner); in __mutex_trylock_or_owner()
137 old = atomic_long_cmpxchg_acquire(&lock->owner, owner, curr | flags); in __mutex_trylock_or_owner()
150 static inline bool __mutex_trylock(struct mutex *lock) in __mutex_trylock() argument
152 return !__mutex_trylock_or_owner(lock); in __mutex_trylock()
166 static __always_inline bool __mutex_trylock_fast(struct mutex *lock) in __mutex_trylock_fast() argument
171 if (atomic_long_try_cmpxchg_acquire(&lock->owner, &zero, curr)) in __mutex_trylock_fast()
177 static __always_inline bool __mutex_unlock_fast(struct mutex *lock) in __mutex_unlock_fast() argument
181 if (atomic_long_cmpxchg_release(&lock->owner, curr, 0UL) == curr) in __mutex_unlock_fast()
188 static inline void __mutex_set_flag(struct mutex *lock, unsigned long flag) in __mutex_set_flag() argument
190 atomic_long_or(flag, &lock->owner); in __mutex_set_flag()
193 static inline void __mutex_clear_flag(struct mutex *lock, unsigned long flag) in __mutex_clear_flag() argument
195 atomic_long_andnot(flag, &lock->owner); in __mutex_clear_flag()
198 static inline bool __mutex_waiter_is_first(struct mutex *lock, struct mutex_waiter *waiter) in __mutex_waiter_is_first() argument
200 return list_first_entry(&lock->wait_list, struct mutex_waiter, list) == waiter; in __mutex_waiter_is_first()
204 * Add @waiter to a given location in the lock wait_list and set the
208 __mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter, in __mutex_add_waiter() argument
211 debug_mutex_add_waiter(lock, waiter, current); in __mutex_add_waiter()
214 if (__mutex_waiter_is_first(lock, waiter)) in __mutex_add_waiter()
215 __mutex_set_flag(lock, MUTEX_FLAG_WAITERS); in __mutex_add_waiter()
219 __mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter) in __mutex_remove_waiter() argument
222 if (likely(list_empty(&lock->wait_list))) in __mutex_remove_waiter()
223 __mutex_clear_flag(lock, MUTEX_FLAGS); in __mutex_remove_waiter()
225 debug_mutex_remove_waiter(lock, waiter, current); in __mutex_remove_waiter()
234 static void __mutex_handoff(struct mutex *lock, struct task_struct *task) in __mutex_handoff() argument
236 unsigned long owner = atomic_long_read(&lock->owner); in __mutex_handoff()
251 old = atomic_long_cmpxchg_release(&lock->owner, owner, new); in __mutex_handoff()
261 * We split the mutex lock/unlock logic into separate fastpath and
266 static void __sched __mutex_lock_slowpath(struct mutex *lock);
270 * @lock: the mutex to be acquired
272 * Lock the mutex exclusively for this task. If the mutex is not
289 void __sched mutex_lock(struct mutex *lock) in mutex_lock() argument
293 if (!__mutex_trylock_fast(lock)) in mutex_lock()
294 __mutex_lock_slowpath(lock); in mutex_lock()
302 * It (the new transaction) makes a request for a lock being held
307 * An older transaction makes a request for a lock being held by
377 __ww_mutex_die(struct mutex *lock, struct mutex_waiter *waiter, in __ww_mutex_die() argument
385 debug_mutex_wake_waiter(lock, waiter); in __ww_mutex_die()
393 * Wound-Wait; wound a younger @hold_ctx if it holds the lock.
395 * Wound the lock holder if there are waiters with older transactions than
396 * the lock holders. Even if multiple waiters may wound the lock holder,
399 static bool __ww_mutex_wound(struct mutex *lock, in __ww_mutex_wound() argument
403 struct task_struct *owner = __mutex_owner(lock); in __ww_mutex_wound()
405 lockdep_assert_held(&lock->wait_lock); in __ww_mutex_wound()
442 * We just acquired @lock under @ww_ctx, if there are later contexts waiting
454 __ww_mutex_check_waiters(struct mutex *lock, struct ww_acquire_ctx *ww_ctx) in __ww_mutex_check_waiters() argument
458 lockdep_assert_held(&lock->wait_lock); in __ww_mutex_check_waiters()
460 list_for_each_entry(cur, &lock->wait_list, list) { in __ww_mutex_check_waiters()
464 if (__ww_mutex_die(lock, cur, ww_ctx) || in __ww_mutex_check_waiters()
465 __ww_mutex_wound(lock, cur->ww_ctx, ww_ctx)) in __ww_mutex_check_waiters()
471 * After acquiring lock with fastpath, where we do not hold wait_lock, set ctx
475 ww_mutex_set_context_fastpath(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in ww_mutex_set_context_fastpath() argument
477 ww_mutex_lock_acquired(lock, ctx); in ww_mutex_set_context_fastpath()
480 * The lock->ctx update should be visible on all cores before in ww_mutex_set_context_fastpath()
497 if (likely(!(atomic_long_read(&lock->base.owner) & MUTEX_FLAG_WAITERS))) in ww_mutex_set_context_fastpath()
504 spin_lock(&lock->base.wait_lock); in ww_mutex_set_context_fastpath()
505 __ww_mutex_check_waiters(&lock->base, ctx); in ww_mutex_set_context_fastpath()
506 spin_unlock(&lock->base.wait_lock); in ww_mutex_set_context_fastpath()
512 bool ww_mutex_spin_on_owner(struct mutex *lock, struct ww_acquire_ctx *ww_ctx, in ww_mutex_spin_on_owner() argument
517 ww = container_of(lock, struct ww_mutex, base); in ww_mutex_spin_on_owner()
536 * lock from a waiter with an earlier stamp, since the in ww_mutex_spin_on_owner()
537 * other thread may already own a lock that we also in ww_mutex_spin_on_owner()
540 if (!waiter && (atomic_long_read(&lock->owner) & MUTEX_FLAG_WAITERS)) in ww_mutex_spin_on_owner()
547 if (waiter && !__mutex_waiter_is_first(lock, waiter)) in ww_mutex_spin_on_owner()
560 bool mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner, in mutex_spin_on_owner() argument
566 while (__mutex_owner(lock) == owner) { in mutex_spin_on_owner()
569 * checking lock->owner still matches owner. If that fails, in mutex_spin_on_owner()
576 * Use vcpu_is_preempted to detect lock holder preemption issue. in mutex_spin_on_owner()
584 if (ww_ctx && !ww_mutex_spin_on_owner(lock, ww_ctx, waiter)) { in mutex_spin_on_owner()
599 static inline int mutex_can_spin_on_owner(struct mutex *lock) in mutex_can_spin_on_owner() argument
608 owner = __mutex_owner(lock); in mutex_can_spin_on_owner()
611 * As lock holder preemption issue, we both skip spinning if task is not in mutex_can_spin_on_owner()
619 * If lock->owner is not set, the mutex has been released. Return true in mutex_can_spin_on_owner()
629 * We try to spin for acquisition when we find that the lock owner
631 * need to reschedule. The rationale is that if the lock owner is
632 * running, it is likely to release the lock soon.
634 * The mutex spinners are queued up using MCS lock so that only one
636 * going to happen, there is no point in going through the lock/unlock
639 * Returns true when the lock was taken, otherwise false, indicating
643 * queue. The waiter-spinner will spin on the lock directly and concurrently
648 mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx, in mutex_optimistic_spin() argument
656 * is not going to take OSQ lock anyway, there is no need in mutex_optimistic_spin()
659 if (!mutex_can_spin_on_owner(lock)) in mutex_optimistic_spin()
665 * MCS (queued) lock first before spinning on the owner field. in mutex_optimistic_spin()
667 if (!osq_lock(&lock->osq)) in mutex_optimistic_spin()
675 owner = __mutex_trylock_or_owner(lock); in mutex_optimistic_spin()
681 * release the lock or go to sleep. in mutex_optimistic_spin()
683 if (!mutex_spin_on_owner(lock, owner, ww_ctx, waiter)) in mutex_optimistic_spin()
696 osq_unlock(&lock->osq); in mutex_optimistic_spin()
703 osq_unlock(&lock->osq); in mutex_optimistic_spin()
708 * reschedule now, before we try-lock the mutex. This avoids getting in mutex_optimistic_spin()
724 mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx, in mutex_optimistic_spin() argument
731 static noinline void __sched __mutex_unlock_slowpath(struct mutex *lock, unsigned long ip);
735 * @lock: the mutex to be released
744 void __sched mutex_unlock(struct mutex *lock) in mutex_unlock() argument
747 if (__mutex_unlock_fast(lock)) in mutex_unlock()
750 __mutex_unlock_slowpath(lock, _RET_IP_); in mutex_unlock()
756 * @lock: the mutex to be released
765 void __sched ww_mutex_unlock(struct ww_mutex *lock) in ww_mutex_unlock() argument
771 if (lock->ctx) { in ww_mutex_unlock()
773 DEBUG_LOCKS_WARN_ON(!lock->ctx->acquired); in ww_mutex_unlock()
775 if (lock->ctx->acquired > 0) in ww_mutex_unlock()
776 lock->ctx->acquired--; in ww_mutex_unlock()
777 lock->ctx = NULL; in ww_mutex_unlock()
780 mutex_unlock(&lock->base); in ww_mutex_unlock()
786 __ww_mutex_kill(struct mutex *lock, struct ww_acquire_ctx *ww_ctx) in __ww_mutex_kill() argument
792 ww = container_of(lock, struct ww_mutex, base); in __ww_mutex_kill()
804 * Check the wound condition for the current lock acquire.
808 * Wait-Die: If we're trying to acquire a lock already held by an older
815 __ww_mutex_check_kill(struct mutex *lock, struct mutex_waiter *waiter, in __ww_mutex_check_kill() argument
818 struct ww_mutex *ww = container_of(lock, struct ww_mutex, base); in __ww_mutex_check_kill()
827 return __ww_mutex_kill(lock, ctx); in __ww_mutex_check_kill()
833 return __ww_mutex_kill(lock, ctx); in __ww_mutex_check_kill()
840 list_for_each_entry_continue_reverse(cur, &lock->wait_list, list) { in __ww_mutex_check_kill()
844 return __ww_mutex_kill(lock, ctx); in __ww_mutex_check_kill()
852 * first. Such that older contexts are preferred to acquire the lock over
863 struct mutex *lock, in __ww_mutex_add_waiter() argument
871 __mutex_add_waiter(lock, waiter, &lock->wait_list); in __ww_mutex_add_waiter()
882 * may wound the lock holder. in __ww_mutex_add_waiter()
884 pos = &lock->wait_list; in __ww_mutex_add_waiter()
885 list_for_each_entry_reverse(cur, &lock->wait_list, list) { in __ww_mutex_add_waiter()
893 * die the moment it would acquire the lock. in __ww_mutex_add_waiter()
896 int ret = __ww_mutex_kill(lock, ww_ctx); in __ww_mutex_add_waiter()
908 __ww_mutex_die(lock, cur, ww_ctx); in __ww_mutex_add_waiter()
911 __mutex_add_waiter(lock, waiter, pos); in __ww_mutex_add_waiter()
918 struct ww_mutex *ww = container_of(lock, struct ww_mutex, base); in __ww_mutex_add_waiter()
926 __ww_mutex_wound(lock, ww_ctx, ww->ctx); in __ww_mutex_add_waiter()
933 * Lock a mutex (possibly interruptible), slowpath:
936 __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass, in __mutex_lock_common() argument
950 DEBUG_LOCKS_WARN_ON(lock->magic != lock); in __mutex_lock_common()
953 ww = container_of(lock, struct ww_mutex, base); in __mutex_lock_common()
968 mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip); in __mutex_lock_common()
970 if (__mutex_trylock(lock) || in __mutex_lock_common()
971 mutex_optimistic_spin(lock, ww_ctx, NULL)) { in __mutex_lock_common()
972 /* got the lock, yay! */ in __mutex_lock_common()
973 lock_acquired(&lock->dep_map, ip); in __mutex_lock_common()
980 spin_lock(&lock->wait_lock); in __mutex_lock_common()
984 if (__mutex_trylock(lock)) { in __mutex_lock_common()
986 __ww_mutex_check_waiters(lock, ww_ctx); in __mutex_lock_common()
991 debug_mutex_lock_common(lock, &waiter); in __mutex_lock_common()
993 lock_contended(&lock->dep_map, ip); in __mutex_lock_common()
997 __mutex_add_waiter(lock, &waiter, &lock->wait_list); in __mutex_lock_common()
1008 ret = __ww_mutex_add_waiter(&waiter, lock, ww_ctx); in __mutex_lock_common()
1023 * mutex_unlock() handing the lock off to us, do a trylock in __mutex_lock_common()
1027 if (__mutex_trylock(lock)) in __mutex_lock_common()
1032 * wait_lock. This ensures the lock cancellation is ordered in __mutex_lock_common()
1041 ret = __ww_mutex_check_kill(lock, &waiter, ww_ctx); in __mutex_lock_common()
1046 spin_unlock(&lock->wait_lock); in __mutex_lock_common()
1049 first = __mutex_waiter_is_first(lock, &waiter); in __mutex_lock_common()
1051 __mutex_set_flag(lock, MUTEX_FLAG_HANDOFF); in __mutex_lock_common()
1059 if (__mutex_trylock(lock) || in __mutex_lock_common()
1060 (first && mutex_optimistic_spin(lock, ww_ctx, &waiter))) in __mutex_lock_common()
1063 spin_lock(&lock->wait_lock); in __mutex_lock_common()
1065 spin_lock(&lock->wait_lock); in __mutex_lock_common()
1071 * Wound-Wait; we stole the lock (!first_waiter), check the in __mutex_lock_common()
1075 !__mutex_waiter_is_first(lock, &waiter)) in __mutex_lock_common()
1076 __ww_mutex_check_waiters(lock, ww_ctx); in __mutex_lock_common()
1079 __mutex_remove_waiter(lock, &waiter); in __mutex_lock_common()
1084 /* got the lock - cleanup and rejoice! */ in __mutex_lock_common()
1085 lock_acquired(&lock->dep_map, ip); in __mutex_lock_common()
1090 spin_unlock(&lock->wait_lock); in __mutex_lock_common()
1096 __mutex_remove_waiter(lock, &waiter); in __mutex_lock_common()
1098 spin_unlock(&lock->wait_lock); in __mutex_lock_common()
1100 mutex_release(&lock->dep_map, ip); in __mutex_lock_common()
1106 __mutex_lock(struct mutex *lock, long state, unsigned int subclass, in __mutex_lock() argument
1109 return __mutex_lock_common(lock, state, subclass, nest_lock, ip, NULL, false); in __mutex_lock()
1113 __ww_mutex_lock(struct mutex *lock, long state, unsigned int subclass, in __ww_mutex_lock() argument
1117 return __mutex_lock_common(lock, state, subclass, nest_lock, ip, ww_ctx, true); in __ww_mutex_lock()
1122 mutex_lock_nested(struct mutex *lock, unsigned int subclass) in mutex_lock_nested() argument
1124 __mutex_lock(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_); in mutex_lock_nested()
1130 _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest) in _mutex_lock_nest_lock() argument
1132 __mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, nest, _RET_IP_); in _mutex_lock_nest_lock()
1137 mutex_lock_killable_nested(struct mutex *lock, unsigned int subclass) in mutex_lock_killable_nested() argument
1139 return __mutex_lock(lock, TASK_KILLABLE, subclass, NULL, _RET_IP_); in mutex_lock_killable_nested()
1144 mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass) in mutex_lock_interruptible_nested() argument
1146 return __mutex_lock(lock, TASK_INTERRUPTIBLE, subclass, NULL, _RET_IP_); in mutex_lock_interruptible_nested()
1151 mutex_lock_io_nested(struct mutex *lock, unsigned int subclass) in mutex_lock_io_nested() argument
1158 __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, in mutex_lock_io_nested()
1165 ww_mutex_deadlock_injection(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in ww_mutex_deadlock_injection() argument
1179 ctx->contending_lock = lock; in ww_mutex_deadlock_injection()
1181 ww_mutex_unlock(lock); in ww_mutex_deadlock_injection()
1191 ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in ww_mutex_lock() argument
1196 ret = __ww_mutex_lock(&lock->base, TASK_UNINTERRUPTIBLE, in ww_mutex_lock()
1200 return ww_mutex_deadlock_injection(lock, ctx); in ww_mutex_lock()
1207 ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in ww_mutex_lock_interruptible() argument
1212 ret = __ww_mutex_lock(&lock->base, TASK_INTERRUPTIBLE, in ww_mutex_lock_interruptible()
1217 return ww_mutex_deadlock_injection(lock, ctx); in ww_mutex_lock_interruptible()
1226 * Release the lock, slowpath:
1228 static noinline void __sched __mutex_unlock_slowpath(struct mutex *lock, unsigned long ip) in __mutex_unlock_slowpath() argument
1234 mutex_release(&lock->dep_map, ip); in __mutex_unlock_slowpath()
1237 * Release the lock before (potentially) taking the spinlock such that in __mutex_unlock_slowpath()
1243 owner = atomic_long_read(&lock->owner); in __mutex_unlock_slowpath()
1255 old = atomic_long_cmpxchg_release(&lock->owner, owner, in __mutex_unlock_slowpath()
1267 spin_lock(&lock->wait_lock); in __mutex_unlock_slowpath()
1268 debug_mutex_unlock(lock); in __mutex_unlock_slowpath()
1269 if (!list_empty(&lock->wait_list)) { in __mutex_unlock_slowpath()
1272 list_first_entry(&lock->wait_list, in __mutex_unlock_slowpath()
1277 debug_mutex_wake_waiter(lock, waiter); in __mutex_unlock_slowpath()
1282 __mutex_handoff(lock, next); in __mutex_unlock_slowpath()
1284 spin_unlock(&lock->wait_lock); in __mutex_unlock_slowpath()
1295 __mutex_lock_killable_slowpath(struct mutex *lock);
1298 __mutex_lock_interruptible_slowpath(struct mutex *lock);
1302 * @lock: The mutex to be acquired.
1304 * Lock the mutex like mutex_lock(). If a signal is delivered while the
1309 * Return: 0 if the lock was successfully acquired or %-EINTR if a
1312 int __sched mutex_lock_interruptible(struct mutex *lock) in mutex_lock_interruptible() argument
1316 if (__mutex_trylock_fast(lock)) in mutex_lock_interruptible()
1319 return __mutex_lock_interruptible_slowpath(lock); in mutex_lock_interruptible()
1326 * @lock: The mutex to be acquired.
1328 * Lock the mutex like mutex_lock(). If a signal which will be fatal to
1333 * Return: 0 if the lock was successfully acquired or %-EINTR if a
1336 int __sched mutex_lock_killable(struct mutex *lock) in mutex_lock_killable() argument
1340 if (__mutex_trylock_fast(lock)) in mutex_lock_killable()
1343 return __mutex_lock_killable_slowpath(lock); in mutex_lock_killable()
1349 * @lock: The mutex to be acquired.
1351 * Lock the mutex like mutex_lock(). While the task is waiting for this
1357 void __sched mutex_lock_io(struct mutex *lock) in mutex_lock_io() argument
1362 mutex_lock(lock); in mutex_lock_io()
1368 __mutex_lock_slowpath(struct mutex *lock) in __mutex_lock_slowpath() argument
1370 __mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, NULL, _RET_IP_); in __mutex_lock_slowpath()
1374 __mutex_lock_killable_slowpath(struct mutex *lock) in __mutex_lock_killable_slowpath() argument
1376 return __mutex_lock(lock, TASK_KILLABLE, 0, NULL, _RET_IP_); in __mutex_lock_killable_slowpath()
1380 __mutex_lock_interruptible_slowpath(struct mutex *lock) in __mutex_lock_interruptible_slowpath() argument
1382 return __mutex_lock(lock, TASK_INTERRUPTIBLE, 0, NULL, _RET_IP_); in __mutex_lock_interruptible_slowpath()
1386 __ww_mutex_lock_slowpath(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in __ww_mutex_lock_slowpath() argument
1388 return __ww_mutex_lock(&lock->base, TASK_UNINTERRUPTIBLE, 0, NULL, in __ww_mutex_lock_slowpath()
1393 __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock, in __ww_mutex_lock_interruptible_slowpath() argument
1396 return __ww_mutex_lock(&lock->base, TASK_INTERRUPTIBLE, 0, NULL, in __ww_mutex_lock_interruptible_slowpath()
1404 * @lock: the mutex to be acquired
1416 int __sched mutex_trylock(struct mutex *lock) in mutex_trylock() argument
1421 DEBUG_LOCKS_WARN_ON(lock->magic != lock); in mutex_trylock()
1424 locked = __mutex_trylock(lock); in mutex_trylock()
1426 mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_); in mutex_trylock()
1434 ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in ww_mutex_lock() argument
1438 if (__mutex_trylock_fast(&lock->base)) { in ww_mutex_lock()
1440 ww_mutex_set_context_fastpath(lock, ctx); in ww_mutex_lock()
1444 return __ww_mutex_lock_slowpath(lock, ctx); in ww_mutex_lock()
1449 ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx) in ww_mutex_lock_interruptible() argument
1453 if (__mutex_trylock_fast(&lock->base)) { in ww_mutex_lock_interruptible()
1455 ww_mutex_set_context_fastpath(lock, ctx); in ww_mutex_lock_interruptible()
1459 return __ww_mutex_lock_interruptible_slowpath(lock, ctx); in ww_mutex_lock_interruptible()
1468 * @lock: the mutex to return holding if we dec to 0
1470 * return true and hold lock if we dec to 0, return false otherwise
1472 int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock) in atomic_dec_and_mutex_lock() argument
1477 /* we might hit 0, so take the lock */ in atomic_dec_and_mutex_lock()
1478 mutex_lock(lock); in atomic_dec_and_mutex_lock()
1481 mutex_unlock(lock); in atomic_dec_and_mutex_lock()
1484 /* we hit 0, and we hold the lock */ in atomic_dec_and_mutex_lock()