lib/dec_and_lock.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/export.h>
   3 #include <linux/spinlock.h>
   4 #include <linux/atomic.h>
   5
   6 /*
   7  * This is an implementation of the notion of "decrement a
   8  * reference count, and return locked if it decremented to zero".
   9  *
  10  * NOTE NOTE NOTE! This is _not_ equivalent to
  11  *
  12  *      if (atomic_dec_and_test(&atomic)) {
  13  *              spin_lock(&lock);
  14  *              return 1;
  15  *      }
  16  *      return 0;
  17  *
  18  * because the spin-lock and the decrement must be
  19  * "atomic".
  20  */
  21 int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock)
  22 {
  23         /* Subtract 1 from counter unless that drops it to 0 (ie. it was 1) */
  24         if (atomic_add_unless(atomic, -1, 1))
  25                 return 0;
  26
  27         /* Otherwise do it the slow way */
  28         spin_lock(lock);
  29         if (atomic_dec_and_test(atomic))
  30                 return 1;
  31         spin_unlock(lock);
  32         return 0;
  33 }
  34
  35 EXPORT_SYMBOL(_atomic_dec_and_lock);
  36
  37 int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock,
  38                                  unsigned long *flags)
  39 {
  40         /* Subtract 1 from counter unless that drops it to 0 (ie. it was 1) */
  41         if (atomic_add_unless(atomic, -1, 1))
  42                 return 0;
  43
  44         /* Otherwise do it the slow way */
  45         spin_lock_irqsave(lock, *flags);
  46         if (atomic_dec_and_test(atomic))
  47                 return 1;
  48         spin_unlock_irqrestore(lock, *flags);
  49         return 0;
  50 }
  51 EXPORT_SYMBOL(_atomic_dec_and_lock_irqsave);
  52
  53 int _atomic_dec_and_raw_lock(atomic_t *atomic, raw_spinlock_t *lock)
  54 {
  55         /* Subtract 1 from counter unless that drops it to 0 (ie. it was 1) */
  56         if (atomic_add_unless(atomic, -1, 1))
  57                 return 0;
  58
  59         /* Otherwise do it the slow way */
  60         raw_spin_lock(lock);
  61         if (atomic_dec_and_test(atomic))
  62                 return 1;
  63         raw_spin_unlock(lock);
  64         return 0;
  65 }
  66 EXPORT_SYMBOL(_atomic_dec_and_raw_lock);
  67
  68 int _atomic_dec_and_raw_lock_irqsave(atomic_t *atomic, raw_spinlock_t *lock,
  69                                      unsigned long *flags)
  70 {
  71         /* Subtract 1 from counter unless that drops it to 0 (ie. it was 1) */
  72         if (atomic_add_unless(atomic, -1, 1))
  73                 return 0;
  74
  75         /* Otherwise do it the slow way */
  76         raw_spin_lock_irqsave(lock, *flags);
  77         if (atomic_dec_and_test(atomic))
  78                 return 1;
  79         raw_spin_unlock_irqrestore(lock, *flags);
  80         return 0;
  81 }
  82 EXPORT_SYMBOL(_atomic_dec_and_raw_lock_irqsave);