This patch adds the __refcount_dec_and_lock macro to generate code for a
lock specific refcount_dec_and_lock implementation. Existing
refcount_dec_and_lock implementation are updated to use the new
__refcount_dec_and_lock macro. In future other lock implementation can
added to use the refcount_dec_and_lock trick to only hold the lock when
the refcount is going to be zero. Per subsystem own lock implementation
can use the macro as well to provide such implementation for their own
locking type.
Co-developed: Peter Zijlstra <[email protected]>
Signed-off-by: Alexander Aring <[email protected]>
---
include/linux/refcount.h | 25 +++++++++++++++++++++++++
lib/refcount.c | 36 ++++++------------------------------
2 files changed, 31 insertions(+), 30 deletions(-)
diff --git a/include/linux/refcount.h b/include/linux/refcount.h
index 741cc6295f54..d5cf40d3f4bc 100644
--- a/include/linux/refcount.h
+++ b/include/linux/refcount.h
@@ -362,6 +362,31 @@ static inline void refcount_dec(refcount_t *r)
extern __must_check bool refcount_dec_if_one(refcount_t *r);
extern __must_check bool refcount_dec_not_one(refcount_t *r);
+/**
+ * __refcount_dec_and_lock - macro to create code to holding a lock if being
+ * able to decremnt refcount to 0
+ * @_ref: the refcount
+ * @_lock: lock function call code
+ * @_unlock: unlock function call code
+ *
+ * The result will be directly returned as a right operand operation. Uusally
+ * the caller use it directly after a return statement.
+ */
+#define __refcount_dec_and_lock(_ref, _lock, _unlock) \
+({ \
+ bool _ret = false; \
+ \
+ if (!refcount_dec_not_one(_ref)) { \
+ _lock; \
+ if (!refcount_dec_and_test(_ref)) \
+ _unlock; \
+ else \
+ _ret = true; \
+ } \
+ \
+ _ret; \
+})
+
/**
* refcount_dec_and_mutex_lock - return holding mutex if able to decrement
* refcount to 0
diff --git a/lib/refcount.c b/lib/refcount.c
index c37edf66994f..5511498df708 100644
--- a/lib/refcount.c
+++ b/lib/refcount.c
@@ -96,46 +96,22 @@ EXPORT_SYMBOL(refcount_dec_not_one);
bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock)
{
- if (refcount_dec_not_one(r))
- return false;
-
- mutex_lock(lock);
- if (!refcount_dec_and_test(r)) {
- mutex_unlock(lock);
- return false;
- }
-
- return true;
+ return __refcount_dec_and_lock(r, mutex_lock(lock),
+ mutex_unlock(lock));
}
EXPORT_SYMBOL(refcount_dec_and_mutex_lock);
bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock)
{
- if (refcount_dec_not_one(r))
- return false;
-
- spin_lock(lock);
- if (!refcount_dec_and_test(r)) {
- spin_unlock(lock);
- return false;
- }
-
- return true;
+ return __refcount_dec_and_lock(r, spin_lock(lock),
+ spin_unlock(lock));
}
EXPORT_SYMBOL(refcount_dec_and_lock);
bool refcount_dec_and_lock_irqsave(refcount_t *r, spinlock_t *lock,
unsigned long *flags)
{
- if (refcount_dec_not_one(r))
- return false;
-
- spin_lock_irqsave(lock, *flags);
- if (!refcount_dec_and_test(r)) {
- spin_unlock_irqrestore(lock, *flags);
- return false;
- }
-
- return true;
+ return __refcount_dec_and_lock(r, spin_lock_irqsave(lock, *flags),
+ spin_unlock_irqrestore(lock, *flags));
}
EXPORT_SYMBOL(refcount_dec_and_lock_irqsave);
--
2.39.3