kernel/locking/mutex.c

   1 /*
   2  * kernel/locking/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  *
  13  *  - 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  *
  18  * Also see Documentation/mutex-design.txt.
  19  */
  20 #include <linux/mutex.h>
  21 #include <linux/ww_mutex.h>
  22 #include <linux/sched.h>
  23 #include <linux/sched/rt.h>
  24 #include <linux/export.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/debug_locks.h>
  28 #include "mcs_spinlock.h"
  29
  30 /*
  31  * In the DEBUG case we are using the "NULL fastpath" for mutexes,
  32  * which forces all calls into the slowpath:
  33  */
  34 #ifdef CONFIG_DEBUG_MUTEXES
  35 # include "mutex-debug.h"
  36 # include <asm-generic/mutex-null.h>
  37 #else
  38 # include "mutex.h"
  39 # include <asm/mutex.h>
  40 #endif
  41
  42 /*
  43  * A negative mutex count indicates that waiters are sleeping waiting for the
  44  * mutex.
  45  */
  46 #define MUTEX_SHOW_NO_WAITER(mutex)     (atomic_read(&(mutex)->count) >= 0)
  47
  48 void
  49 __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
  50 {
  51         atomic_set(&lock->count, 1);
  52         spin_lock_init(&lock->wait_lock);
  53         INIT_LIST_HEAD(&lock->wait_list);
  54         mutex_clear_owner(lock);
  55 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
  56         lock->mcs_lock = NULL;
  57 #endif
  58
  59         debug_mutex_init(lock, name, key);
  60 }
  61
  62 EXPORT_SYMBOL(__mutex_init);
  63
  64 #ifndef CONFIG_DEBUG_LOCK_ALLOC
  65 /*
  66  * We split the mutex lock/unlock logic into separate fastpath and
  67  * slowpath functions, to reduce the register pressure on the fastpath.
  68  * We also put the fastpath first in the kernel image, to make sure the
  69  * branch is predicted by the CPU as default-untaken.
  70  */
  71 static __used noinline void __sched
  72 __mutex_lock_slowpath(atomic_t *lock_count);
  73
  74 /**
  75  * mutex_lock - acquire the mutex
  76  * @lock: the mutex to be acquired
  77  *
  78  * Lock the mutex exclusively for this task. If the mutex is not
  79  * available right now, it will sleep until it can get it.
  80  *
  81  * The mutex must later on be released by the same task that
  82  * acquired it. Recursive locking is not allowed. The task
  83  * may not exit without first unlocking the mutex. Also, kernel
  84  * memory where the mutex resides mutex must not be freed with
  85  * the mutex still locked. The mutex must first be initialized
  86  * (or statically defined) before it can be locked. memset()-ing
  87  * the mutex to 0 is not allowed.
  88  *
  89  * ( The CONFIG_DEBUG_MUTEXES .config option turns on debugging
  90  *   checks that will enforce the restrictions and will also do
  91  *   deadlock debugging. )
  92  *
  93  * This function is similar to (but not equivalent to) down().
  94  */
  95 void __sched mutex_lock(struct mutex *lock)
  96 {
  97         might_sleep();
  98         /*
  99          * The locking fastpath is the 1->0 transition from
 100          * 'unlocked' into 'locked' state.
 101          */
 102         __mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);
 103         mutex_set_owner(lock);
 104 }
 105
 106 EXPORT_SYMBOL(mutex_lock);
 107 #endif
 108
 109 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
 110 /*
 111  * In order to avoid a stampede of mutex spinners from acquiring the mutex
 112  * more or less simultaneously, the spinners need to acquire a MCS lock
 113  * first before spinning on the owner field.
 114  *
 115  */
 116
 117 /*
 118  * Mutex spinning code migrated from kernel/sched/core.c
 119  */
 120
 121 static inline bool owner_running(struct mutex *lock, struct task_struct *owner)
 122 {
 123         if (lock->owner != owner)
 124                 return false;
 125
 126         /*
 127          * Ensure we emit the owner->on_cpu, dereference _after_ checking
 128          * lock->owner still matches owner, if that fails, owner might
 129          * point to free()d memory, if it still matches, the rcu_read_lock()
 130          * ensures the memory stays valid.
 131          */
 132         barrier();
 133
 134         return owner->on_cpu;
 135 }
 136
 137 /*
 138  * Look out! "owner" is an entirely speculative pointer
 139  * access and not reliable.
 140  */
 141 static noinline
 142 int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner)
 143 {
 144         rcu_read_lock();
 145         while (owner_running(lock, owner)) {
 146                 if (need_resched())
 147                         break;
 148
 149                 arch_mutex_cpu_relax();
 150         }
 151         rcu_read_unlock();
 152
 153         /*
 154          * We break out the loop above on need_resched() and when the
 155          * owner changed, which is a sign for heavy contention. Return
 156          * success only when lock->owner is NULL.
 157          */
 158         return lock->owner == NULL;
 159 }
 160
 161 /*
 162  * Initial check for entering the mutex spinning loop
 163  */
 164 static inline int mutex_can_spin_on_owner(struct mutex *lock)
 165 {
 166         struct task_struct *owner;
 167         int retval = 1;
 168
 169         if (need_resched())
 170                 return 0;
 171
 172         rcu_read_lock();
 173         owner = ACCESS_ONCE(lock->owner);
 174         if (owner)
 175                 retval = owner->on_cpu;
 176         rcu_read_unlock();
 177         /*
 178          * if lock->owner is not set, the mutex owner may have just acquired
 179          * it and not set the owner yet or the mutex has been released.
 180          */
 181         return retval;
 182 }
 183 #endif
 184
 185 static __used noinline void __sched __mutex_unlock_slowpath(atomic_t *lock_count);
 186
 187 /**
 188  * mutex_unlock - release the mutex
 189  * @lock: the mutex to be released
 190  *
 191  * Unlock a mutex that has been locked by this task previously.
 192  *
 193  * This function must not be used in interrupt context. Unlocking
 194  * of a not locked mutex is not allowed.
 195  *
 196  * This function is similar to (but not equivalent to) up().
 197  */
 198 void __sched mutex_unlock(struct mutex *lock)
 199 {
 200         /*
 201          * The unlocking fastpath is the 0->1 transition from 'locked'
 202          * into 'unlocked' state:
 203          */
 204 #ifndef CONFIG_DEBUG_MUTEXES
 205         /*
 206          * When debugging is enabled we must not clear the owner before time,
 207          * the slow path will always be taken, and that clears the owner field
 208          * after verifying that it was indeed current.
 209          */
 210         mutex_clear_owner(lock);
 211 #endif
 212         __mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);
 213 }
 214
 215 EXPORT_SYMBOL(mutex_unlock);
 216
 217 /**
 218  * ww_mutex_unlock - release the w/w mutex
 219  * @lock: the mutex to be released
 220  *
 221  * Unlock a mutex that has been locked by this task previously with any of the
 222  * ww_mutex_lock* functions (with or without an acquire context). It is
 223  * forbidden to release the locks after releasing the acquire context.
 224  *
 225  * This function must not be used in interrupt context. Unlocking
 226  * of a unlocked mutex is not allowed.
 227  */
 228 void __sched ww_mutex_unlock(struct ww_mutex *lock)
 229 {
 230         /*
 231          * The unlocking fastpath is the 0->1 transition from 'locked'
 232          * into 'unlocked' state:
 233          */
 234         if (lock->ctx) {
 235 #ifdef CONFIG_DEBUG_MUTEXES
 236                 DEBUG_LOCKS_WARN_ON(!lock->ctx->acquired);
 237 #endif
 238                 if (lock->ctx->acquired > 0)
 239                         lock->ctx->acquired--;
 240                 lock->ctx = NULL;
 241         }
 242
 243 #ifndef CONFIG_DEBUG_MUTEXES
 244         /*
 245          * When debugging is enabled we must not clear the owner before time,
 246          * the slow path will always be taken, and that clears the owner field
 247          * after verifying that it was indeed current.
 248          */
 249         mutex_clear_owner(&lock->base);
 250 #endif
 251         __mutex_fastpath_unlock(&lock->base.count, __mutex_unlock_slowpath);
 252 }
 253 EXPORT_SYMBOL(ww_mutex_unlock);
 254
 255 static inline int __sched
 256 __mutex_lock_check_stamp(struct mutex *lock, struct ww_acquire_ctx *ctx)
 257 {
 258         struct ww_mutex *ww = container_of(lock, struct ww_mutex, base);
 259         struct ww_acquire_ctx *hold_ctx = ACCESS_ONCE(ww->ctx);
 260
 261         if (!hold_ctx)
 262                 return 0;
 263
 264         if (unlikely(ctx == hold_ctx))
 265                 return -EALREADY;
 266
 267         if (ctx->stamp - hold_ctx->stamp <= LONG_MAX &&
 268             (ctx->stamp != hold_ctx->stamp || ctx > hold_ctx)) {
 269 #ifdef CONFIG_DEBUG_MUTEXES
 270                 DEBUG_LOCKS_WARN_ON(ctx->contending_lock);
 271                 ctx->contending_lock = ww;
 272 #endif
 273                 return -EDEADLK;
 274         }
 275
 276         return 0;
 277 }
 278
 279 static __always_inline void ww_mutex_lock_acquired(struct ww_mutex *ww,
 280                                                    struct ww_acquire_ctx *ww_ctx)
 281 {
 282 #ifdef CONFIG_DEBUG_MUTEXES
 283         /*
 284          * If this WARN_ON triggers, you used ww_mutex_lock to acquire,
 285          * but released with a normal mutex_unlock in this call.
 286          *
 287          * This should never happen, always use ww_mutex_unlock.
 288          */
 289         DEBUG_LOCKS_WARN_ON(ww->ctx);
 290
 291         /*
 292          * Not quite done after calling ww_acquire_done() ?
 293          */
 294         DEBUG_LOCKS_WARN_ON(ww_ctx->done_acquire);
 295
 296         if (ww_ctx->contending_lock) {
 297                 /*
 298                  * After -EDEADLK you tried to
 299                  * acquire a different ww_mutex? Bad!
 300                  */
 301                 DEBUG_LOCKS_WARN_ON(ww_ctx->contending_lock != ww);
 302
 303                 /*
 304                  * You called ww_mutex_lock after receiving -EDEADLK,
 305                  * but 'forgot' to unlock everything else first?
 306                  */
 307                 DEBUG_LOCKS_WARN_ON(ww_ctx->acquired > 0);
 308                 ww_ctx->contending_lock = NULL;
 309         }
 310
 311         /*
 312          * Naughty, using a different class will lead to undefined behavior!
 313          */
 314         DEBUG_LOCKS_WARN_ON(ww_ctx->ww_class != ww->ww_class);
 315 #endif
 316         ww_ctx->acquired++;
 317 }
 318
 319 /*
 320  * after acquiring lock with fastpath or when we lost out in contested
 321  * slowpath, set ctx and wake up any waiters so they can recheck.
 322  *
 323  * This function is never called when CONFIG_DEBUG_LOCK_ALLOC is set,
 324  * as the fastpath and opportunistic spinning are disabled in that case.
 325  */
 326 static __always_inline void
 327 ww_mutex_set_context_fastpath(struct ww_mutex *lock,
 328                                struct ww_acquire_ctx *ctx)
 329 {
 330         unsigned long flags;
 331         struct mutex_waiter *cur;
 332
 333         ww_mutex_lock_acquired(lock, ctx);
 334
 335         lock->ctx = ctx;
 336
 337         /*
 338          * The lock->ctx update should be visible on all cores before
 339          * the atomic read is done, otherwise contended waiters might be
 340          * missed. The contended waiters will either see ww_ctx == NULL
 341          * and keep spinning, or it will acquire wait_lock, add itself
 342          * to waiter list and sleep.
 343          */
 344         smp_mb(); /* ^^^ */
 345
 346         /*
 347          * Check if lock is contended, if not there is nobody to wake up
 348          */
 349         if (likely(atomic_read(&lock->base.count) == 0))
 350                 return;
 351
 352         /*
 353          * Uh oh, we raced in fastpath, wake up everyone in this case,
 354          * so they can see the new lock->ctx.
 355          */
 356         spin_lock_mutex(&lock->base.wait_lock, flags);
 357         list_for_each_entry(cur, &lock->base.wait_list, list) {
 358                 debug_mutex_wake_waiter(&lock->base, cur);
 359                 wake_up_process(cur->task);
 360         }
 361         spin_unlock_mutex(&lock->base.wait_lock, flags);
 362 }
 363
 364 /*
 365  * Lock a mutex (possibly interruptible), slowpath:
 366  */
 367 static __always_inline int __sched
 368 __mutex_lock_common(struct mutex *lock, long state, unsigned int subclass,
 369                     struct lockdep_map *nest_lock, unsigned long ip,
 370                     struct ww_acquire_ctx *ww_ctx, const bool use_ww_ctx)
 371 {
 372         struct task_struct *task = current;
 373         struct mutex_waiter waiter;
 374         unsigned long flags;
 375         int ret;
 376
 377         preempt_disable();
 378         mutex_acquire_nest(&lock->dep_map, subclass, 0, nest_lock, ip);
 379
 380 #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
 381         /*
 382          * Optimistic spinning.
 383          *
 384          * We try to spin for acquisition when we find that there are no
 385          * pending waiters and the lock owner is currently running on a
 386          * (different) CPU.
 387          *
 388          * The rationale is that if the lock owner is running, it is likely to
 389          * release the lock soon.
 390          *
 391          * Since this needs the lock owner, and this mutex implementation
 392          * doesn't track the owner atomically in the lock field, we need to
 393          * track it non-atomically.
 394          *
 395          * We can't do this for DEBUG_MUTEXES because that relies on wait_lock
 396          * to serialize everything.
 397          *
 398          * The mutex spinners are queued up using MCS lock so that only one
 399          * spinner can compete for the mutex. However, if mutex spinning isn't
 400          * going to happen, there is no point in going through the lock/unlock
 401          * overhead.
 402          */
 403         if (!mutex_can_spin_on_owner(lock))
 404                 goto slowpath;
 405
 406         mcs_spin_lock(&lock->mcs_lock, &node);
 407         for (;;) {
 408                 struct task_struct *owner;
 409
 410                 if (use_ww_ctx && ww_ctx->acquired > 0) {
 411                         struct ww_mutex *ww;
 412
 413                         ww = container_of(lock, struct ww_mutex, base);
 414                         /*
 415                          * If ww->ctx is set the contents are undefined, only
 416                          * by acquiring wait_lock there is a guarantee that
 417                          * they are not invalid when reading.
 418                          *
 419                          * As such, when deadlock detection needs to be
 420                          * performed the optimistic spinning cannot be done.
 421                          */
 422                         if (ACCESS_ONCE(ww->ctx))
 423                                 break;
 424                 }
 425
 426                 /*
 427                  * If there's an owner, wait for it to either
 428                  * release the lock or go to sleep.
 429                  */
 430                 owner = ACCESS_ONCE(lock->owner);
 431                 if (owner && !mutex_spin_on_owner(lock, owner))
 432                         break;
 433
 434                 if ((atomic_read(&lock->count) == 1) &&
 435                     (atomic_cmpxchg(&lock->count, 1, 0) == 1)) {
 436                         lock_acquired(&lock->dep_map, ip);
 437                         if (use_ww_ctx) {
 438                                 struct ww_mutex *ww;
 439                                 ww = container_of(lock, struct ww_mutex, base);
 440
 441                                 ww_mutex_set_context_fastpath(ww, ww_ctx);
 442                         }
 443
 444                         mutex_set_owner(lock);
 445                         mcs_spin_unlock(&lock->mcs_lock, &node);
 446                         preempt_enable();
 447                         return 0;
 448                 }
 449
 450                 /*
 451                  * When there's no owner, we might have preempted between the
 452                  * owner acquiring the lock and setting the owner field. If
 453                  * we're an RT task that will live-lock because we won't let
 454                  * the owner complete.
 455                  */
 456                 if (!owner && (need_resched() || rt_task(task)))
 457                         break;
 458
 459                 /*
 460                  * The cpu_relax() call is a compiler barrier which forces
 461                  * everything in this loop to be re-loaded. We don't need
 462                  * memory barriers as we'll eventually observe the right
 463                  * values at the cost of a few extra spins.
 464                  */
 465                 arch_mutex_cpu_relax();
 466         }
 467         mcs_spin_unlock(&lock->mcs_lock, &node);
 468 slowpath:
 469 #endif
 470         spin_lock_mutex(&lock->wait_lock, flags);
 471
 472         /* once more, can we acquire the lock? */
 473         if (MUTEX_SHOW_NO_WAITER(lock) && (atomic_xchg(&lock->count, 0) == 1))
 474                 goto skip_wait;
 475
 476         debug_mutex_lock_common(lock, &waiter);
 477         debug_mutex_add_waiter(lock, &waiter, task_thread_info(task));
 478
 479         /* add waiting tasks to the end of the waitqueue (FIFO): */
 480         list_add_tail(&waiter.list, &lock->wait_list);
 481         waiter.task = task;
 482
 483         lock_contended(&lock->dep_map, ip);
 484
 485         for (;;) {
 486                 /*
 487                  * Lets try to take the lock again - this is needed even if
 488                  * we get here for the first time (shortly after failing to
 489                  * acquire the lock), to make sure that we get a wakeup once
 490                  * it's unlocked. Later on, if we sleep, this is the
 491                  * operation that gives us the lock. We xchg it to -1, so
 492                  * that when we release the lock, we properly wake up the
 493                  * other waiters:
 494                  */
 495                 if (MUTEX_SHOW_NO_WAITER(lock) &&
 496                     (atomic_xchg(&lock->count, -1) == 1))
 497                         break;
 498
 499                 /*
 500                  * got a signal? (This code gets eliminated in the
 501                  * TASK_UNINTERRUPTIBLE case.)
 502                  */
 503                 if (unlikely(signal_pending_state(state, task))) {
 504                         ret = -EINTR;
 505                         goto err;
 506                 }
 507
 508                 if (use_ww_ctx && ww_ctx->acquired > 0) {
 509                         ret = __mutex_lock_check_stamp(lock, ww_ctx);
 510                         if (ret)
 511                                 goto err;
 512                 }
 513
 514                 __set_task_state(task, state);
 515
 516                 /* didn't get the lock, go to sleep: */
 517                 spin_unlock_mutex(&lock->wait_lock, flags);
 518                 schedule_preempt_disabled();
 519                 spin_lock_mutex(&lock->wait_lock, flags);
 520         }
 521         mutex_remove_waiter(lock, &waiter, current_thread_info());
 522         /* set it to 0 if there are no waiters left: */
 523         if (likely(list_empty(&lock->wait_list)))
 524                 atomic_set(&lock->count, 0);
 525         debug_mutex_free_waiter(&waiter);
 526
 527 skip_wait:
 528         /* got the lock - cleanup and rejoice! */
 529         lock_acquired(&lock->dep_map, ip);
 530         mutex_set_owner(lock);
 531
 532         if (use_ww_ctx) {
 533                 struct ww_mutex *ww = container_of(lock, struct ww_mutex, base);
 534                 struct mutex_waiter *cur;
 535
 536                 /*
 537                  * This branch gets optimized out for the common case,
 538                  * and is only important for ww_mutex_lock.
 539                  */
 540                 ww_mutex_lock_acquired(ww, ww_ctx);
 541                 ww->ctx = ww_ctx;
 542
 543                 /*
 544                  * Give any possible sleeping processes the chance to wake up,
 545                  * so they can recheck if they have to back off.
 546                  */
 547                 list_for_each_entry(cur, &lock->wait_list, list) {
 548                         debug_mutex_wake_waiter(lock, cur);
 549                         wake_up_process(cur->task);
 550                 }
 551         }
 552
 553         spin_unlock_mutex(&lock->wait_lock, flags);
 554         preempt_enable();
 555         return 0;
 556
 557 err:
 558         mutex_remove_waiter(lock, &waiter, task_thread_info(task));
 559         spin_unlock_mutex(&lock->wait_lock, flags);
 560         debug_mutex_free_waiter(&waiter);
 561         mutex_release(&lock->dep_map, 1, ip);
 562         preempt_enable();
 563         return ret;
 564 }
 565
 566 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 567 void __sched
 568 mutex_lock_nested(struct mutex *lock, unsigned int subclass)
 569 {
 570         might_sleep();
 571         __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE,
 572                             subclass, NULL, _RET_IP_, NULL, 0);
 573 }
 574
 575 EXPORT_SYMBOL_GPL(mutex_lock_nested);
 576
 577 void __sched
 578 _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest)
 579 {
 580         might_sleep();
 581         __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE,
 582                             0, nest, _RET_IP_, NULL, 0);
 583 }
 584
 585 EXPORT_SYMBOL_GPL(_mutex_lock_nest_lock);
 586
 587 int __sched
 588 mutex_lock_killable_nested(struct mutex *lock, unsigned int subclass)
 589 {
 590         might_sleep();
 591         return __mutex_lock_common(lock, TASK_KILLABLE,
 592                                    subclass, NULL, _RET_IP_, NULL, 0);
 593 }
 594 EXPORT_SYMBOL_GPL(mutex_lock_killable_nested);
 595
 596 int __sched
 597 mutex_lock_interruptible_nested(struct mutex *lock, unsigned int subclass)
 598 {
 599         might_sleep();
 600         return __mutex_lock_common(lock, TASK_INTERRUPTIBLE,
 601                                    subclass, NULL, _RET_IP_, NULL, 0);
 602 }
 603
 604 EXPORT_SYMBOL_GPL(mutex_lock_interruptible_nested);
 605
 606 static inline int
 607 ww_mutex_deadlock_injection(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
 608 {
 609 #ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
 610         unsigned tmp;
 611
 612         if (ctx->deadlock_inject_countdown-- == 0) {
 613                 tmp = ctx->deadlock_inject_interval;
 614                 if (tmp > UINT_MAX/4)
 615                         tmp = UINT_MAX;
 616                 else
 617                         tmp = tmp*2 + tmp + tmp/2;
 618
 619                 ctx->deadlock_inject_interval = tmp;
 620                 ctx->deadlock_inject_countdown = tmp;
 621                 ctx->contending_lock = lock;
 622
 623                 ww_mutex_unlock(lock);
 624
 625                 return -EDEADLK;
 626         }
 627 #endif
 628
 629         return 0;
 630 }
 631
 632 int __sched
 633 __ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
 634 {
 635         int ret;
 636
 637         might_sleep();
 638         ret =  __mutex_lock_common(&lock->base, TASK_UNINTERRUPTIBLE,
 639                                    0, &ctx->dep_map, _RET_IP_, ctx, 1);
 640         if (!ret && ctx->acquired > 1)
 641                 return ww_mutex_deadlock_injection(lock, ctx);
 642
 643         return ret;
 644 }
 645 EXPORT_SYMBOL_GPL(__ww_mutex_lock);
 646
 647 int __sched
 648 __ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
 649 {
 650         int ret;
 651
 652         might_sleep();
 653         ret = __mutex_lock_common(&lock->base, TASK_INTERRUPTIBLE,
 654                                   0, &ctx->dep_map, _RET_IP_, ctx, 1);
 655
 656         if (!ret && ctx->acquired > 1)
 657                 return ww_mutex_deadlock_injection(lock, ctx);
 658
 659         return ret;
 660 }
 661 EXPORT_SYMBOL_GPL(__ww_mutex_lock_interruptible);
 662
 663 #endif
 664
 665 /*
 666  * Release the lock, slowpath:
 667  */
 668 static inline void
 669 __mutex_unlock_common_slowpath(atomic_t *lock_count, int nested)
 670 {
 671         struct mutex *lock = container_of(lock_count, struct mutex, count);
 672         unsigned long flags;
 673
 674         /*
 675          * some architectures leave the lock unlocked in the fastpath failure
 676          * case, others need to leave it locked. In the later case we have to
 677          * unlock it here
 678          */
 679         if (__mutex_slowpath_needs_to_unlock())
 680                 atomic_set(&lock->count, 1);
 681
 682         spin_lock_mutex(&lock->wait_lock, flags);
 683         mutex_release(&lock->dep_map, nested, _RET_IP_);
 684         debug_mutex_unlock(lock);
 685
 686         if (!list_empty(&lock->wait_list)) {
 687                 /* get the first entry from the wait-list: */
 688                 struct mutex_waiter *waiter =
 689                                 list_entry(lock->wait_list.next,
 690                                            struct mutex_waiter, list);
 691
 692                 debug_mutex_wake_waiter(lock, waiter);
 693
 694                 wake_up_process(waiter->task);
 695         }
 696
 697         spin_unlock_mutex(&lock->wait_lock, flags);
 698 }
 699
 700 /*
 701  * Release the lock, slowpath:
 702  */
 703 static __used noinline void
 704 __mutex_unlock_slowpath(atomic_t *lock_count)
 705 {
 706         __mutex_unlock_common_slowpath(lock_count, 1);
 707 }
 708
 709 #ifndef CONFIG_DEBUG_LOCK_ALLOC
 710 /*
 711  * Here come the less common (and hence less performance-critical) APIs:
 712  * mutex_lock_interruptible() and mutex_trylock().
 713  */
 714 static noinline int __sched
 715 __mutex_lock_killable_slowpath(struct mutex *lock);
 716
 717 static noinline int __sched
 718 __mutex_lock_interruptible_slowpath(struct mutex *lock);
 719
 720 /**
 721  * mutex_lock_interruptible - acquire the mutex, interruptible
 722  * @lock: the mutex to be acquired
 723  *
 724  * Lock the mutex like mutex_lock(), and return 0 if the mutex has
 725  * been acquired or sleep until the mutex becomes available. If a
 726  * signal arrives while waiting for the lock then this function
 727  * returns -EINTR.
 728  *
 729  * This function is similar to (but not equivalent to) down_interruptible().
 730  */
 731 int __sched mutex_lock_interruptible(struct mutex *lock)
 732 {
 733         int ret;
 734
 735         might_sleep();
 736         ret =  __mutex_fastpath_lock_retval(&lock->count);
 737         if (likely(!ret)) {
 738                 mutex_set_owner(lock);
 739                 return 0;
 740         } else
 741                 return __mutex_lock_interruptible_slowpath(lock);
 742 }
 743
 744 EXPORT_SYMBOL(mutex_lock_interruptible);
 745
 746 int __sched mutex_lock_killable(struct mutex *lock)
 747 {
 748         int ret;
 749
 750         might_sleep();
 751         ret = __mutex_fastpath_lock_retval(&lock->count);
 752         if (likely(!ret)) {
 753                 mutex_set_owner(lock);
 754                 return 0;
 755         } else
 756                 return __mutex_lock_killable_slowpath(lock);
 757 }
 758 EXPORT_SYMBOL(mutex_lock_killable);
 759
 760 static __used noinline void __sched
 761 __mutex_lock_slowpath(atomic_t *lock_count)
 762 {
 763         struct mutex *lock = container_of(lock_count, struct mutex, count);
 764
 765         __mutex_lock_common(lock, TASK_UNINTERRUPTIBLE, 0,
 766                             NULL, _RET_IP_, NULL, 0);
 767 }
 768
 769 static noinline int __sched
 770 __mutex_lock_killable_slowpath(struct mutex *lock)
 771 {
 772         return __mutex_lock_common(lock, TASK_KILLABLE, 0,
 773                                    NULL, _RET_IP_, NULL, 0);
 774 }
 775
 776 static noinline int __sched
 777 __mutex_lock_interruptible_slowpath(struct mutex *lock)
 778 {
 779         return __mutex_lock_common(lock, TASK_INTERRUPTIBLE, 0,
 780                                    NULL, _RET_IP_, NULL, 0);
 781 }
 782
 783 static noinline int __sched
 784 __ww_mutex_lock_slowpath(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
 785 {
 786         return __mutex_lock_common(&lock->base, TASK_UNINTERRUPTIBLE, 0,
 787                                    NULL, _RET_IP_, ctx, 1);
 788 }
 789
 790 static noinline int __sched
 791 __ww_mutex_lock_interruptible_slowpath(struct ww_mutex *lock,
 792                                             struct ww_acquire_ctx *ctx)
 793 {
 794         return __mutex_lock_common(&lock->base, TASK_INTERRUPTIBLE, 0,
 795                                    NULL, _RET_IP_, ctx, 1);
 796 }
 797
 798 #endif
 799
 800 /*
 801  * Spinlock based trylock, we take the spinlock and check whether we
 802  * can get the lock:
 803  */
 804 static inline int __mutex_trylock_slowpath(atomic_t *lock_count)
 805 {
 806         struct mutex *lock = container_of(lock_count, struct mutex, count);
 807         unsigned long flags;
 808         int prev;
 809
 810         spin_lock_mutex(&lock->wait_lock, flags);
 811
 812         prev = atomic_xchg(&lock->count, -1);
 813         if (likely(prev == 1)) {
 814                 mutex_set_owner(lock);
 815                 mutex_acquire(&lock->dep_map, 0, 1, _RET_IP_);
 816         }
 817
 818         /* Set it back to 0 if there are no waiters: */
 819         if (likely(list_empty(&lock->wait_list)))
 820                 atomic_set(&lock->count, 0);
 821
 822         spin_unlock_mutex(&lock->wait_lock, flags);
 823
 824         return prev == 1;
 825 }
 826
 827 /**
 828  * mutex_trylock - try to acquire the mutex, without waiting
 829  * @lock: the mutex to be acquired
 830  *
 831  * Try to acquire the mutex atomically. Returns 1 if the mutex
 832  * has been acquired successfully, and 0 on contention.
 833  *
 834  * NOTE: this function follows the spin_trylock() convention, so
 835  * it is negated from the down_trylock() return values! Be careful
 836  * about this when converting semaphore users to mutexes.
 837  *
 838  * This function must not be used in interrupt context. The
 839  * mutex must be released by the same task that acquired it.
 840  */
 841 int __sched mutex_trylock(struct mutex *lock)
 842 {
 843         int ret;
 844
 845         ret = __mutex_fastpath_trylock(&lock->count, __mutex_trylock_slowpath);
 846         if (ret)
 847                 mutex_set_owner(lock);
 848
 849         return ret;
 850 }
 851 EXPORT_SYMBOL(mutex_trylock);
 852
 853 #ifndef CONFIG_DEBUG_LOCK_ALLOC
 854 int __sched
 855 __ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
 856 {
 857         int ret;
 858
 859         might_sleep();
 860
 861         ret = __mutex_fastpath_lock_retval(&lock->base.count);
 862
 863         if (likely(!ret)) {
 864                 ww_mutex_set_context_fastpath(lock, ctx);
 865                 mutex_set_owner(&lock->base);
 866         } else
 867                 ret = __ww_mutex_lock_slowpath(lock, ctx);
 868         return ret;
 869 }
 870 EXPORT_SYMBOL(__ww_mutex_lock);
 871
 872 int __sched
 873 __ww_mutex_lock_interruptible(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
 874 {
 875         int ret;
 876
 877         might_sleep();
 878
 879         ret = __mutex_fastpath_lock_retval(&lock->base.count);
 880
 881         if (likely(!ret)) {
 882                 ww_mutex_set_context_fastpath(lock, ctx);
 883                 mutex_set_owner(&lock->base);
 884         } else
 885                 ret = __ww_mutex_lock_interruptible_slowpath(lock, ctx);
 886         return ret;
 887 }
 888 EXPORT_SYMBOL(__ww_mutex_lock_interruptible);
 889
 890 #endif
 891
 892 /**
 893  * atomic_dec_and_mutex_lock - return holding mutex if we dec to 0
 894  * @cnt: the atomic which we are to dec
 895  * @lock: the mutex to return holding if we dec to 0
 896  *
 897  * return true and hold lock if we dec to 0, return false otherwise
 898  */
 899 int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock)
 900 {
 901         /* dec if we can't possibly hit 0 */
 902         if (atomic_add_unless(cnt, -1, 1))
 903                 return 0;
 904         /* we might hit 0, so take the lock */
 905         mutex_lock(lock);
 906         if (!atomic_dec_and_test(cnt)) {
 907                 /* when we actually did the dec, we didn't hit 0 */
 908                 mutex_unlock(lock);
 909                 return 0;
 910         }
 911         /* we hit 0, and we hold the lock */
 912         return 1;
 913 }
 914 EXPORT_SYMBOL(atomic_dec_and_mutex_lock);