Linux Audio

Check our new training course

Loading...
v5.14.15
  1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/export.h>
  3#include <linux/lockref.h>
  4
  5#if USE_CMPXCHG_LOCKREF
  6
  7/*
  8 * Note that the "cmpxchg()" reloads the "old" value for the
  9 * failure case.
 10 */
 11#define CMPXCHG_LOOP(CODE, SUCCESS) do {					\
 12	int retry = 100;							\
 13	struct lockref old;							\
 14	BUILD_BUG_ON(sizeof(old) != 8);						\
 15	old.lock_count = READ_ONCE(lockref->lock_count);			\
 16	while (likely(arch_spin_value_unlocked(old.lock.rlock.raw_lock))) {  	\
 17		struct lockref new = old, prev = old;				\
 18		CODE								\
 19		old.lock_count = cmpxchg64_relaxed(&lockref->lock_count,	\
 20						   old.lock_count,		\
 21						   new.lock_count);		\
 22		if (likely(old.lock_count == prev.lock_count)) {		\
 23			SUCCESS;						\
 24		}								\
 25		if (!--retry)							\
 26			break;							\
 27		cpu_relax();							\
 28	}									\
 29} while (0)
 30
 31#else
 32
 33#define CMPXCHG_LOOP(CODE, SUCCESS) do { } while (0)
 34
 35#endif
 36
 37/**
 38 * lockref_get - Increments reference count unconditionally
 39 * @lockref: pointer to lockref structure
 40 *
 41 * This operation is only valid if you already hold a reference
 42 * to the object, so you know the count cannot be zero.
 43 */
 44void lockref_get(struct lockref *lockref)
 45{
 46	CMPXCHG_LOOP(
 47		new.count++;
 48	,
 49		return;
 50	);
 51
 52	spin_lock(&lockref->lock);
 53	lockref->count++;
 54	spin_unlock(&lockref->lock);
 55}
 56EXPORT_SYMBOL(lockref_get);
 57
 58/**
 59 * lockref_get_not_zero - Increments count unless the count is 0 or dead
 60 * @lockref: pointer to lockref structure
 61 * Return: 1 if count updated successfully or 0 if count was zero
 62 */
 63int lockref_get_not_zero(struct lockref *lockref)
 64{
 65	int retval;
 66
 67	CMPXCHG_LOOP(
 68		new.count++;
 69		if (old.count <= 0)
 70			return 0;
 71	,
 72		return 1;
 73	);
 74
 75	spin_lock(&lockref->lock);
 76	retval = 0;
 77	if (lockref->count > 0) {
 78		lockref->count++;
 79		retval = 1;
 80	}
 81	spin_unlock(&lockref->lock);
 82	return retval;
 83}
 84EXPORT_SYMBOL(lockref_get_not_zero);
 85
 86/**
 87 * lockref_put_not_zero - Decrements count unless count <= 1 before decrement
 88 * @lockref: pointer to lockref structure
 89 * Return: 1 if count updated successfully or 0 if count would become zero
 90 */
 91int lockref_put_not_zero(struct lockref *lockref)
 92{
 93	int retval;
 94
 95	CMPXCHG_LOOP(
 96		new.count--;
 97		if (old.count <= 1)
 98			return 0;
 99	,
100		return 1;
101	);
102
103	spin_lock(&lockref->lock);
104	retval = 0;
105	if (lockref->count > 1) {
106		lockref->count--;
107		retval = 1;
108	}
109	spin_unlock(&lockref->lock);
110	return retval;
111}
112EXPORT_SYMBOL(lockref_put_not_zero);
113
114/**
115 * lockref_get_or_lock - Increments count unless the count is 0 or dead
116 * @lockref: pointer to lockref structure
117 * Return: 1 if count updated successfully or 0 if count was zero
118 * and we got the lock instead.
119 */
120int lockref_get_or_lock(struct lockref *lockref)
121{
122	CMPXCHG_LOOP(
123		new.count++;
124		if (old.count <= 0)
125			break;
126	,
127		return 1;
128	);
129
130	spin_lock(&lockref->lock);
131	if (lockref->count <= 0)
132		return 0;
133	lockref->count++;
134	spin_unlock(&lockref->lock);
135	return 1;
136}
137EXPORT_SYMBOL(lockref_get_or_lock);
138
139/**
140 * lockref_put_return - Decrement reference count if possible
141 * @lockref: pointer to lockref structure
142 *
143 * Decrement the reference count and return the new value.
144 * If the lockref was dead or locked, return an error.
145 */
146int lockref_put_return(struct lockref *lockref)
147{
148	CMPXCHG_LOOP(
149		new.count--;
150		if (old.count <= 0)
151			return -1;
152	,
153		return new.count;
154	);
155	return -1;
156}
157EXPORT_SYMBOL(lockref_put_return);
158
159/**
160 * lockref_put_or_lock - decrements count unless count <= 1 before decrement
161 * @lockref: pointer to lockref structure
162 * Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
163 */
164int lockref_put_or_lock(struct lockref *lockref)
165{
166	CMPXCHG_LOOP(
167		new.count--;
168		if (old.count <= 1)
169			break;
170	,
171		return 1;
172	);
173
174	spin_lock(&lockref->lock);
175	if (lockref->count <= 1)
176		return 0;
177	lockref->count--;
178	spin_unlock(&lockref->lock);
179	return 1;
180}
181EXPORT_SYMBOL(lockref_put_or_lock);
182
183/**
184 * lockref_mark_dead - mark lockref dead
185 * @lockref: pointer to lockref structure
186 */
187void lockref_mark_dead(struct lockref *lockref)
188{
189	assert_spin_locked(&lockref->lock);
190	lockref->count = -128;
191}
192EXPORT_SYMBOL(lockref_mark_dead);
193
194/**
195 * lockref_get_not_dead - Increments count unless the ref is dead
196 * @lockref: pointer to lockref structure
197 * Return: 1 if count updated successfully or 0 if lockref was dead
198 */
199int lockref_get_not_dead(struct lockref *lockref)
200{
201	int retval;
202
203	CMPXCHG_LOOP(
204		new.count++;
205		if (old.count < 0)
206			return 0;
207	,
208		return 1;
209	);
210
211	spin_lock(&lockref->lock);
212	retval = 0;
213	if (lockref->count >= 0) {
214		lockref->count++;
215		retval = 1;
216	}
217	spin_unlock(&lockref->lock);
218	return retval;
219}
220EXPORT_SYMBOL(lockref_get_not_dead);
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/export.h>
  3#include <linux/lockref.h>
  4
  5#if USE_CMPXCHG_LOCKREF
  6
  7/*
  8 * Note that the "cmpxchg()" reloads the "old" value for the
  9 * failure case.
 10 */
 11#define CMPXCHG_LOOP(CODE, SUCCESS) do {					\
 12	int retry = 100;							\
 13	struct lockref old;							\
 14	BUILD_BUG_ON(sizeof(old) != 8);						\
 15	old.lock_count = READ_ONCE(lockref->lock_count);			\
 16	while (likely(arch_spin_value_unlocked(old.lock.rlock.raw_lock))) {  	\
 17		struct lockref new = old;					\
 18		CODE								\
 19		if (likely(try_cmpxchg64_relaxed(&lockref->lock_count,		\
 20						 &old.lock_count,		\
 21						 new.lock_count))) {		\
 
 22			SUCCESS;						\
 23		}								\
 24		if (!--retry)							\
 25			break;							\
 
 26	}									\
 27} while (0)
 28
 29#else
 30
 31#define CMPXCHG_LOOP(CODE, SUCCESS) do { } while (0)
 32
 33#endif
 34
 35/**
 36 * lockref_get - Increments reference count unconditionally
 37 * @lockref: pointer to lockref structure
 38 *
 39 * This operation is only valid if you already hold a reference
 40 * to the object, so you know the count cannot be zero.
 41 */
 42void lockref_get(struct lockref *lockref)
 43{
 44	CMPXCHG_LOOP(
 45		new.count++;
 46	,
 47		return;
 48	);
 49
 50	spin_lock(&lockref->lock);
 51	lockref->count++;
 52	spin_unlock(&lockref->lock);
 53}
 54EXPORT_SYMBOL(lockref_get);
 55
 56/**
 57 * lockref_get_not_zero - Increments count unless the count is 0 or dead
 58 * @lockref: pointer to lockref structure
 59 * Return: 1 if count updated successfully or 0 if count was zero
 60 */
 61int lockref_get_not_zero(struct lockref *lockref)
 62{
 63	int retval;
 64
 65	CMPXCHG_LOOP(
 66		new.count++;
 67		if (old.count <= 0)
 68			return 0;
 69	,
 70		return 1;
 71	);
 72
 73	spin_lock(&lockref->lock);
 74	retval = 0;
 75	if (lockref->count > 0) {
 76		lockref->count++;
 77		retval = 1;
 78	}
 79	spin_unlock(&lockref->lock);
 80	return retval;
 81}
 82EXPORT_SYMBOL(lockref_get_not_zero);
 83
 84/**
 85 * lockref_put_not_zero - Decrements count unless count <= 1 before decrement
 86 * @lockref: pointer to lockref structure
 87 * Return: 1 if count updated successfully or 0 if count would become zero
 88 */
 89int lockref_put_not_zero(struct lockref *lockref)
 90{
 91	int retval;
 92
 93	CMPXCHG_LOOP(
 94		new.count--;
 95		if (old.count <= 1)
 96			return 0;
 97	,
 98		return 1;
 99	);
100
101	spin_lock(&lockref->lock);
102	retval = 0;
103	if (lockref->count > 1) {
104		lockref->count--;
105		retval = 1;
106	}
107	spin_unlock(&lockref->lock);
108	return retval;
109}
110EXPORT_SYMBOL(lockref_put_not_zero);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
111
112/**
113 * lockref_put_return - Decrement reference count if possible
114 * @lockref: pointer to lockref structure
115 *
116 * Decrement the reference count and return the new value.
117 * If the lockref was dead or locked, return an error.
118 */
119int lockref_put_return(struct lockref *lockref)
120{
121	CMPXCHG_LOOP(
122		new.count--;
123		if (old.count <= 0)
124			return -1;
125	,
126		return new.count;
127	);
128	return -1;
129}
130EXPORT_SYMBOL(lockref_put_return);
131
132/**
133 * lockref_put_or_lock - decrements count unless count <= 1 before decrement
134 * @lockref: pointer to lockref structure
135 * Return: 1 if count updated successfully or 0 if count <= 1 and lock taken
136 */
137int lockref_put_or_lock(struct lockref *lockref)
138{
139	CMPXCHG_LOOP(
140		new.count--;
141		if (old.count <= 1)
142			break;
143	,
144		return 1;
145	);
146
147	spin_lock(&lockref->lock);
148	if (lockref->count <= 1)
149		return 0;
150	lockref->count--;
151	spin_unlock(&lockref->lock);
152	return 1;
153}
154EXPORT_SYMBOL(lockref_put_or_lock);
155
156/**
157 * lockref_mark_dead - mark lockref dead
158 * @lockref: pointer to lockref structure
159 */
160void lockref_mark_dead(struct lockref *lockref)
161{
162	assert_spin_locked(&lockref->lock);
163	lockref->count = -128;
164}
165EXPORT_SYMBOL(lockref_mark_dead);
166
167/**
168 * lockref_get_not_dead - Increments count unless the ref is dead
169 * @lockref: pointer to lockref structure
170 * Return: 1 if count updated successfully or 0 if lockref was dead
171 */
172int lockref_get_not_dead(struct lockref *lockref)
173{
174	int retval;
175
176	CMPXCHG_LOOP(
177		new.count++;
178		if (old.count < 0)
179			return 0;
180	,
181		return 1;
182	);
183
184	spin_lock(&lockref->lock);
185	retval = 0;
186	if (lockref->count >= 0) {
187		lockref->count++;
188		retval = 1;
189	}
190	spin_unlock(&lockref->lock);
191	return retval;
192}
193EXPORT_SYMBOL(lockref_get_not_dead);