187 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Out-of-line refcount functions.4 */5 6#include <linux/mutex.h>7#include <linux/refcount.h>8#include <linux/spinlock.h>9#include <linux/bug.h>10 11#define REFCOUNT_WARN(str) WARN_ONCE(1, "refcount_t: " str ".\n")12 13void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t)14{15 refcount_set(r, REFCOUNT_SATURATED);16 17 switch (t) {18 case REFCOUNT_ADD_NOT_ZERO_OVF:19 REFCOUNT_WARN("saturated; leaking memory");20 break;21 case REFCOUNT_ADD_OVF:22 REFCOUNT_WARN("saturated; leaking memory");23 break;24 case REFCOUNT_ADD_UAF:25 REFCOUNT_WARN("addition on 0; use-after-free");26 break;27 case REFCOUNT_SUB_UAF:28 REFCOUNT_WARN("underflow; use-after-free");29 break;30 case REFCOUNT_DEC_LEAK:31 REFCOUNT_WARN("decrement hit 0; leaking memory");32 break;33 default:34 REFCOUNT_WARN("unknown saturation event!?");35 }36}37EXPORT_SYMBOL(refcount_warn_saturate);38 39/**40 * refcount_dec_if_one - decrement a refcount if it is 141 * @r: the refcount42 *43 * No atomic_t counterpart, it attempts a 1 -> 0 transition and returns the44 * success thereof.45 *46 * Like all decrement operations, it provides release memory order and provides47 * a control dependency.48 *49 * It can be used like a try-delete operator; this explicit case is provided50 * and not cmpxchg in generic, because that would allow implementing unsafe51 * operations.52 *53 * Return: true if the resulting refcount is 0, false otherwise54 */55bool refcount_dec_if_one(refcount_t *r)56{57 int val = 1;58 59 return atomic_try_cmpxchg_release(&r->refs, &val, 0);60}61EXPORT_SYMBOL(refcount_dec_if_one);62 63/**64 * refcount_dec_not_one - decrement a refcount if it is not 165 * @r: the refcount66 *67 * No atomic_t counterpart, it decrements unless the value is 1, in which case68 * it will return false.69 *70 * Was often done like: atomic_add_unless(&var, -1, 1)71 *72 * Return: true if the decrement operation was successful, false otherwise73 */74bool refcount_dec_not_one(refcount_t *r)75{76 unsigned int new, val = atomic_read(&r->refs);77 78 do {79 if (unlikely(val == REFCOUNT_SATURATED))80 return true;81 82 if (val == 1)83 return false;84 85 new = val - 1;86 if (new > val) {87 WARN_ONCE(new > val, "refcount_t: underflow; use-after-free.\n");88 return true;89 }90 91 } while (!atomic_try_cmpxchg_release(&r->refs, &val, new));92 93 return true;94}95EXPORT_SYMBOL(refcount_dec_not_one);96 97/**98 * refcount_dec_and_mutex_lock - return holding mutex if able to decrement99 * refcount to 0100 * @r: the refcount101 * @lock: the mutex to be locked102 *103 * Similar to atomic_dec_and_mutex_lock(), it will WARN on underflow and fail104 * to decrement when saturated at REFCOUNT_SATURATED.105 *106 * Provides release memory ordering, such that prior loads and stores are done107 * before, and provides a control dependency such that free() must come after.108 * See the comment on top.109 *110 * Return: true and hold mutex if able to decrement refcount to 0, false111 * otherwise112 */113bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock)114{115 if (refcount_dec_not_one(r))116 return false;117 118 mutex_lock(lock);119 if (!refcount_dec_and_test(r)) {120 mutex_unlock(lock);121 return false;122 }123 124 return true;125}126EXPORT_SYMBOL(refcount_dec_and_mutex_lock);127 128/**129 * refcount_dec_and_lock - return holding spinlock if able to decrement130 * refcount to 0131 * @r: the refcount132 * @lock: the spinlock to be locked133 *134 * Similar to atomic_dec_and_lock(), it will WARN on underflow and fail to135 * decrement when saturated at REFCOUNT_SATURATED.136 *137 * Provides release memory ordering, such that prior loads and stores are done138 * before, and provides a control dependency such that free() must come after.139 * See the comment on top.140 *141 * Return: true and hold spinlock if able to decrement refcount to 0, false142 * otherwise143 */144bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock)145{146 if (refcount_dec_not_one(r))147 return false;148 149 spin_lock(lock);150 if (!refcount_dec_and_test(r)) {151 spin_unlock(lock);152 return false;153 }154 155 return true;156}157EXPORT_SYMBOL(refcount_dec_and_lock);158 159/**160 * refcount_dec_and_lock_irqsave - return holding spinlock with disabled161 * interrupts if able to decrement refcount to 0162 * @r: the refcount163 * @lock: the spinlock to be locked164 * @flags: saved IRQ-flags if the is acquired165 *166 * Same as refcount_dec_and_lock() above except that the spinlock is acquired167 * with disabled interrupts.168 *169 * Return: true and hold spinlock if able to decrement refcount to 0, false170 * otherwise171 */172bool refcount_dec_and_lock_irqsave(refcount_t *r, spinlock_t *lock,173 unsigned long *flags)174{175 if (refcount_dec_not_one(r))176 return false;177 178 spin_lock_irqsave(lock, *flags);179 if (!refcount_dec_and_test(r)) {180 spin_unlock_irqrestore(lock, *flags);181 return false;182 }183 184 return true;185}186EXPORT_SYMBOL(refcount_dec_and_lock_irqsave);187