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()
224 static void __mutex_handoff(struct mutex *lock, struct task_struct *task)  in __mutex_handoff()  argument
226 	unsigned long owner = atomic_long_read(&lock->owner);  in __mutex_handoff()
241 		old = atomic_long_cmpxchg_release(&lock->owner, owner, new);  in __mutex_handoff()
251  * We split the mutex lock/unlock logic into separate fastpath and
256 static void __sched __mutex_lock_slowpath(struct mutex *lock);
260  * @lock: the mutex to be acquired
262  * Lock the mutex exclusively for this task. If the mutex is not
279 void __sched mutex_lock(struct mutex *lock)  in mutex_lock()  argument
283 	if (!__mutex_trylock_fast(lock))  in mutex_lock()
284 		__mutex_lock_slowpath(lock);  in mutex_lock()
292  *     It (the new transaction) makes a request for a lock being held
297  *     An older transaction makes a request for a lock being held by
367 __ww_mutex_die(struct mutex *lock, struct mutex_waiter *waiter,  in __ww_mutex_die()  argument
375 		debug_mutex_wake_waiter(lock, waiter);  in __ww_mutex_die()
383  * Wound-Wait; wound a younger @hold_ctx if it holds the lock.
385  * Wound the lock holder if there are waiters with older transactions than
386  * the lock holders. Even if multiple waiters may wound the lock holder,
389 static bool __ww_mutex_wound(struct mutex *lock,  in __ww_mutex_wound()  argument
393 	struct task_struct *owner = __mutex_owner(lock);  in __ww_mutex_wound()
395 	lockdep_assert_held(&lock->wait_lock);  in __ww_mutex_wound()
432  * We just acquired @lock under @ww_ctx, if there are later contexts waiting
444 __ww_mutex_check_waiters(struct mutex *lock, struct ww_acquire_ctx *ww_ctx)  in __ww_mutex_check_waiters()  argument
448 	lockdep_assert_held(&lock->wait_lock);  in __ww_mutex_check_waiters()
450 	list_for_each_entry(cur, &lock->wait_list, list) {  in __ww_mutex_check_waiters()
454 		if (__ww_mutex_die(lock, cur, ww_ctx) ||  in __ww_mutex_check_waiters()
455 		    __ww_mutex_wound(lock, cur->ww_ctx, ww_ctx))  in __ww_mutex_check_waiters()
461  * After acquiring lock with fastpath, where we do not hold wait_lock, set ctx
465 ww_mutex_set_context_fastpath(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in ww_mutex_set_context_fastpath()  argument
467 	ww_mutex_lock_acquired(lock, ctx);  in ww_mutex_set_context_fastpath()
470 	 * The lock->ctx update should be visible on all cores before  in ww_mutex_set_context_fastpath()
487 	if (likely(!(atomic_long_read(&lock->base.owner) & MUTEX_FLAG_WAITERS)))  in ww_mutex_set_context_fastpath()
494 	spin_lock(&lock->base.wait_lock);  in ww_mutex_set_context_fastpath()
495 	__ww_mutex_check_waiters(&lock->base, ctx);  in ww_mutex_set_context_fastpath()
496 	spin_unlock(&lock->base.wait_lock);  in ww_mutex_set_context_fastpath()
502 bool ww_mutex_spin_on_owner(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,  in ww_mutex_spin_on_owner()  argument
507 	ww = container_of(lock, struct ww_mutex, base);  in ww_mutex_spin_on_owner()
526 	 * lock from a waiter with an earlier stamp, since the  in ww_mutex_spin_on_owner()
527 	 * other thread may already own a lock that we also  in ww_mutex_spin_on_owner()
530 	if (!waiter && (atomic_long_read(&lock->owner) & MUTEX_FLAG_WAITERS))  in ww_mutex_spin_on_owner()
537 	if (waiter && !__mutex_waiter_is_first(lock, waiter))  in ww_mutex_spin_on_owner()
550 bool mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner,  in mutex_spin_on_owner()  argument
556 	while (__mutex_owner(lock) == owner) {  in mutex_spin_on_owner()
559 		 * checking lock->owner still matches owner. If that fails,  in mutex_spin_on_owner()
566 		 * Use vcpu_is_preempted to detect lock holder preemption issue.  in mutex_spin_on_owner()
574 		if (ww_ctx && !ww_mutex_spin_on_owner(lock, ww_ctx, waiter)) {  in mutex_spin_on_owner()
589 static inline int mutex_can_spin_on_owner(struct mutex *lock)  in mutex_can_spin_on_owner()  argument
598 	owner = __mutex_owner(lock);  in mutex_can_spin_on_owner()
601 	 * As lock holder preemption issue, we both skip spinning if task is not  in mutex_can_spin_on_owner()
609 	 * If lock->owner is not set, the mutex has been released. Return true  in mutex_can_spin_on_owner()
619  * We try to spin for acquisition when we find that the lock owner
621  * need to reschedule. The rationale is that if the lock owner is
622  * running, it is likely to release the lock soon.
624  * The mutex spinners are queued up using MCS lock so that only one
626  * going to happen, there is no point in going through the lock/unlock
629  * Returns true when the lock was taken, otherwise false, indicating
633  * queue. The waiter-spinner will spin on the lock directly and concurrently
638 mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,  in mutex_optimistic_spin()  argument
646 		 * is not going to take OSQ lock anyway, there is no need  in mutex_optimistic_spin()
649 		if (!mutex_can_spin_on_owner(lock))  in mutex_optimistic_spin()
655 		 * MCS (queued) lock first before spinning on the owner field.  in mutex_optimistic_spin()
657 		if (!osq_lock(&lock->osq))  in mutex_optimistic_spin()
665 		owner = __mutex_trylock_or_owner(lock);  in mutex_optimistic_spin()
671 		 * release the lock or go to sleep.  in mutex_optimistic_spin()
673 		if (!mutex_spin_on_owner(lock, owner, ww_ctx, waiter))  in mutex_optimistic_spin()
686 		osq_unlock(&lock->osq);  in mutex_optimistic_spin()
693 		osq_unlock(&lock->osq);  in mutex_optimistic_spin()
698 	 * reschedule now, before we try-lock the mutex. This avoids getting  in mutex_optimistic_spin()
714 mutex_optimistic_spin(struct mutex *lock, struct ww_acquire_ctx *ww_ctx,  in mutex_optimistic_spin()  argument
721 static noinline void __sched __mutex_unlock_slowpath(struct mutex *lock, unsigned long ip);
725  * @lock: the mutex to be released
734 void __sched mutex_unlock(struct mutex *lock)  in mutex_unlock()  argument
737 	if (__mutex_unlock_fast(lock))  in mutex_unlock()
740 	__mutex_unlock_slowpath(lock, _RET_IP_);  in mutex_unlock()
746  * @lock: the mutex to be released
755 void __sched ww_mutex_unlock(struct ww_mutex *lock)  in ww_mutex_unlock()  argument
761 	if (lock->ctx) {  in ww_mutex_unlock()
763 		DEBUG_LOCKS_WARN_ON(!lock->ctx->acquired);  in ww_mutex_unlock()
765 		if (lock->ctx->acquired > 0)  in ww_mutex_unlock()
766 			lock->ctx->acquired--;  in ww_mutex_unlock()
767 		lock->ctx = NULL;  in ww_mutex_unlock()
770 	mutex_unlock(&lock->base);  in ww_mutex_unlock()
776 __ww_mutex_kill(struct mutex *lock, struct ww_acquire_ctx *ww_ctx)  in __ww_mutex_kill()  argument
782 		ww = container_of(lock, struct ww_mutex, base);  in __ww_mutex_kill()
794  * Check the wound condition for the current lock acquire.
798  * Wait-Die: If we're trying to acquire a lock already held by an older
805 __ww_mutex_check_kill(struct mutex *lock, struct mutex_waiter *waiter,  in __ww_mutex_check_kill()  argument
808 	struct ww_mutex *ww = container_of(lock, struct ww_mutex, base);  in __ww_mutex_check_kill()
817 			return __ww_mutex_kill(lock, ctx);  in __ww_mutex_check_kill()
823 		return __ww_mutex_kill(lock, ctx);  in __ww_mutex_check_kill()
830 	list_for_each_entry_continue_reverse(cur, &lock->wait_list, list) {  in __ww_mutex_check_kill()
834 		return __ww_mutex_kill(lock, ctx);  in __ww_mutex_check_kill()
842  * first. Such that older contexts are preferred to acquire the lock over
853 		      struct mutex *lock,  in __ww_mutex_add_waiter()  argument
861 		__mutex_add_waiter(lock, waiter, &lock->wait_list);  in __ww_mutex_add_waiter()
872 	 * may wound the lock holder.  in __ww_mutex_add_waiter()
874 	pos = &lock->wait_list;  in __ww_mutex_add_waiter()
875 	list_for_each_entry_reverse(cur, &lock->wait_list, list) {  in __ww_mutex_add_waiter()
883 			 * die the moment it would acquire the lock.  in __ww_mutex_add_waiter()
886 				int ret = __ww_mutex_kill(lock, ww_ctx);  in __ww_mutex_add_waiter()
898 		__ww_mutex_die(lock, cur, ww_ctx);  in __ww_mutex_add_waiter()
901 	__mutex_add_waiter(lock, waiter, pos);  in __ww_mutex_add_waiter()
908 		struct ww_mutex *ww = container_of(lock, struct ww_mutex, base);  in __ww_mutex_add_waiter()
916 		__ww_mutex_wound(lock, ww_ctx, ww->ctx);  in __ww_mutex_add_waiter()
923  * Lock a mutex (possibly interruptible), slowpath:
926 __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,  in __mutex_lock_common()  argument
938 	DEBUG_LOCKS_WARN_ON(lock->magic != lock);  in __mutex_lock_common()
941 	ww = container_of(lock, struct ww_mutex, base);  in __mutex_lock_common()
956 	mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);  in __mutex_lock_common()
958 	if (__mutex_trylock(lock) ||  in __mutex_lock_common()
959 	    mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, NULL)) {  in __mutex_lock_common()
960 		/* got the lock, yay! */  in __mutex_lock_common()
961 		lock_acquired(&lock->dep_map, ip);  in __mutex_lock_common()
968 	spin_lock(&lock->wait_lock);  in __mutex_lock_common()
972 	if (__mutex_trylock(lock)) {  in __mutex_lock_common()
974 			__ww_mutex_check_waiters(lock, ww_ctx);  in __mutex_lock_common()
979 	debug_mutex_lock_common(lock, &waiter);  in __mutex_lock_common()
981 	lock_contended(&lock->dep_map, ip);  in __mutex_lock_common()
985 		__mutex_add_waiter(lock, &waiter, &lock->wait_list);  in __mutex_lock_common()
996 		ret = __ww_mutex_add_waiter(&waiter, lock, ww_ctx);  in __mutex_lock_common()
1009 		 * mutex_unlock() handing the lock off to us, do a trylock  in __mutex_lock_common()
1013 		if (__mutex_trylock(lock))  in __mutex_lock_common()
1018 		 * wait_lock. This ensures the lock cancellation is ordered  in __mutex_lock_common()
1027 			ret = __ww_mutex_check_kill(lock, &waiter, ww_ctx);  in __mutex_lock_common()
1032 		spin_unlock(&lock->wait_lock);  in __mutex_lock_common()
1040 			first = __mutex_waiter_is_first(lock, &waiter);  in __mutex_lock_common()
1042 				__mutex_set_flag(lock, MUTEX_FLAG_HANDOFF);  in __mutex_lock_common()
1051 		if (__mutex_trylock(lock) ||  in __mutex_lock_common()
1052 		    (first && mutex_optimistic_spin(lock, ww_ctx, use_ww_ctx, &waiter)))  in __mutex_lock_common()
1055 		spin_lock(&lock->wait_lock);  in __mutex_lock_common()
1057 	spin_lock(&lock->wait_lock);  in __mutex_lock_common()
1063 		 * Wound-Wait; we stole the lock (!first_waiter), check the  in __mutex_lock_common()
1067 		    !__mutex_waiter_is_first(lock, &waiter))  in __mutex_lock_common()
1068 			__ww_mutex_check_waiters(lock, ww_ctx);  in __mutex_lock_common()
1071 	mutex_remove_waiter(lock, &waiter, current);  in __mutex_lock_common()
1072 	if (likely(list_empty(&lock->wait_list)))  in __mutex_lock_common()
1073 		__mutex_clear_flag(lock, MUTEX_FLAGS);  in __mutex_lock_common()
1078 	/* got the lock - cleanup and rejoice! */  in __mutex_lock_common()
1079 	lock_acquired(&lock->dep_map, ip);  in __mutex_lock_common()
1084 	spin_unlock(&lock->wait_lock);  in __mutex_lock_common()
1090 	mutex_remove_waiter(lock, &waiter, current);  in __mutex_lock_common()
1092 	spin_unlock(&lock->wait_lock);  in __mutex_lock_common()
1094 	mutex_release(&lock->dep_map, ip);  in __mutex_lock_common()
1100 __mutex_lock(struct mutex *lock, long state, unsigned int subclass,  in __mutex_lock()  argument
1103 	return __mutex_lock_common(lock, state, subclass, nest_lock, ip, NULL, false);  in __mutex_lock()
1107 __ww_mutex_lock(struct mutex *lock, long state, unsigned int subclass,  in __ww_mutex_lock()  argument
1111 	return __mutex_lock_common(lock, state, subclass, nest_lock, ip, ww_ctx, true);  in __ww_mutex_lock()
1116 mutex_lock_nested(struct mutex *lock, unsigned int subclass)  in mutex_lock_nested()  argument
1118 	__mutex_lock(lock, TASK_UNINTERRUPTIBLE, subclass, NULL, _RET_IP_);  in mutex_lock_nested()
1124 _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest)  in _mutex_lock_nest_lock()  argument
1126 	__mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, nest, _RET_IP_);  in _mutex_lock_nest_lock()
1131 mutex_lock_killable_nested(struct mutex *lock, unsigned int subclass)  in mutex_lock_killable_nested()  argument
1133 	return __mutex_lock(lock, TASK_KILLABLE, subclass, NULL, _RET_IP_);  in mutex_lock_killable_nested()
1138 mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass)  in mutex_lock_interruptible_nested()  argument
1140 	return __mutex_lock(lock, TASK_INTERRUPTIBLE, subclass, NULL, _RET_IP_);  in mutex_lock_interruptible_nested()
1145 mutex_lock_io_nested(struct mutex *lock, unsigned int subclass)  in mutex_lock_io_nested()  argument
1152 	__mutex_lock_common(lock, TASK_UNINTERRUPTIBLE,  in mutex_lock_io_nested()
1159 ww_mutex_deadlock_injection(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in ww_mutex_deadlock_injection()  argument
1173 		ctx->contending_lock = lock;  in ww_mutex_deadlock_injection()
1175 		ww_mutex_unlock(lock);  in ww_mutex_deadlock_injection()
1185 ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in ww_mutex_lock()  argument
1190 	ret =  __ww_mutex_lock(&lock->base, TASK_UNINTERRUPTIBLE,  in ww_mutex_lock()
1194 		return ww_mutex_deadlock_injection(lock, ctx);  in ww_mutex_lock()
1201 ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in ww_mutex_lock_interruptible()  argument
1206 	ret = __ww_mutex_lock(&lock->base, TASK_INTERRUPTIBLE,  in ww_mutex_lock_interruptible()
1211 		return ww_mutex_deadlock_injection(lock, ctx);  in ww_mutex_lock_interruptible()
1220  * Release the lock, slowpath:
1222 static noinline void __sched __mutex_unlock_slowpath(struct mutex *lock, unsigned long ip)  in __mutex_unlock_slowpath()  argument
1228 	mutex_release(&lock->dep_map, ip);  in __mutex_unlock_slowpath()
1231 	 * Release the lock before (potentially) taking the spinlock such that  in __mutex_unlock_slowpath()
1237 	owner = atomic_long_read(&lock->owner);  in __mutex_unlock_slowpath()
1249 		old = atomic_long_cmpxchg_release(&lock->owner, owner,  in __mutex_unlock_slowpath()
1261 	spin_lock(&lock->wait_lock);  in __mutex_unlock_slowpath()
1262 	debug_mutex_unlock(lock);  in __mutex_unlock_slowpath()
1263 	if (!list_empty(&lock->wait_list)) {  in __mutex_unlock_slowpath()
1266 			list_first_entry(&lock->wait_list,  in __mutex_unlock_slowpath()
1271 		debug_mutex_wake_waiter(lock, waiter);  in __mutex_unlock_slowpath()
1276 		__mutex_handoff(lock, next);  in __mutex_unlock_slowpath()
1278 	spin_unlock(&lock->wait_lock);  in __mutex_unlock_slowpath()
1289 __mutex_lock_killable_slowpath(struct mutex *lock);
1292 __mutex_lock_interruptible_slowpath(struct mutex *lock);
1296  * @lock: The mutex to be acquired.
1298  * Lock the mutex like mutex_lock().  If a signal is delivered while the
1303  * Return: 0 if the lock was successfully acquired or %-EINTR if a
1306 int __sched mutex_lock_interruptible(struct mutex *lock)  in mutex_lock_interruptible()  argument
1310 	if (__mutex_trylock_fast(lock))  in mutex_lock_interruptible()
1313 	return __mutex_lock_interruptible_slowpath(lock);  in mutex_lock_interruptible()
1320  * @lock: The mutex to be acquired.
1322  * Lock the mutex like mutex_lock().  If a signal which will be fatal to
1327  * Return: 0 if the lock was successfully acquired or %-EINTR if a
1330 int __sched mutex_lock_killable(struct mutex *lock)  in mutex_lock_killable()  argument
1334 	if (__mutex_trylock_fast(lock))  in mutex_lock_killable()
1337 	return __mutex_lock_killable_slowpath(lock);  in mutex_lock_killable()
1343  * @lock: The mutex to be acquired.
1345  * Lock the mutex like mutex_lock().  While the task is waiting for this
1351 void __sched mutex_lock_io(struct mutex *lock)  in mutex_lock_io()  argument
1356 	mutex_lock(lock);  in mutex_lock_io()
1362 __mutex_lock_slowpath(struct mutex *lock)  in __mutex_lock_slowpath()  argument
1364 	__mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, NULL, _RET_IP_);  in __mutex_lock_slowpath()
1368 __mutex_lock_killable_slowpath(struct mutex *lock)  in __mutex_lock_killable_slowpath()  argument
1370 	return __mutex_lock(lock, TASK_KILLABLE, 0, NULL, _RET_IP_);  in __mutex_lock_killable_slowpath()
1374 __mutex_lock_interruptible_slowpath(struct mutex *lock)  in __mutex_lock_interruptible_slowpath()  argument
1376 	return __mutex_lock(lock, TASK_INTERRUPTIBLE, 0, NULL, _RET_IP_);  in __mutex_lock_interruptible_slowpath()
1380 __ww_mutex_lock_slowpath(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in __ww_mutex_lock_slowpath()  argument
1382 	return __ww_mutex_lock(&lock->base, TASK_UNINTERRUPTIBLE, 0, NULL,  in __ww_mutex_lock_slowpath()
1387 __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,  in __ww_mutex_lock_interruptible_slowpath()  argument
1390 	return __ww_mutex_lock(&lock->base, TASK_INTERRUPTIBLE, 0, NULL,  in __ww_mutex_lock_interruptible_slowpath()
1398  * @lock: the mutex to be acquired
1410 int __sched mutex_trylock(struct mutex *lock)  in mutex_trylock()  argument
1415 	DEBUG_LOCKS_WARN_ON(lock->magic != lock);  in mutex_trylock()
1418 	locked = __mutex_trylock(lock);  in mutex_trylock()
1420 		mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);  in mutex_trylock()
1428 ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in ww_mutex_lock()  argument
1432 	if (__mutex_trylock_fast(&lock->base)) {  in ww_mutex_lock()
1434 			ww_mutex_set_context_fastpath(lock, ctx);  in ww_mutex_lock()
1438 	return __ww_mutex_lock_slowpath(lock, ctx);  in ww_mutex_lock()
1443 ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)  in ww_mutex_lock_interruptible()  argument
1447 	if (__mutex_trylock_fast(&lock->base)) {  in ww_mutex_lock_interruptible()
1449 			ww_mutex_set_context_fastpath(lock, ctx);  in ww_mutex_lock_interruptible()
1453 	return __ww_mutex_lock_interruptible_slowpath(lock, ctx);  in ww_mutex_lock_interruptible()
1462  * @lock: the mutex to return holding if we dec to 0
1464  * return true and hold lock if we dec to 0, return false otherwise
1466 int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)  in atomic_dec_and_mutex_lock()  argument
1471 	/* we might hit 0, so take the lock */  in atomic_dec_and_mutex_lock()
1472 	mutex_lock(lock);  in atomic_dec_and_mutex_lock()
1475 		mutex_unlock(lock);  in atomic_dec_and_mutex_lock()
1478 	/* we hit 0, and we hold the lock */  in atomic_dec_and_mutex_lock()