Lines Matching +full:ref +full:-
1 // SPDX-License-Identifier: GPL-2.0-only
9 #include <linux/percpu-refcount.h>
13 * don't try to detect the ref hitting 0 - which means that get/put can just
15 * particular cpu can (and will) wrap - this is fine, when we go to shutdown the
24 * the ref hitting 0 on every put - this would require global synchronization
28 * the ref can't hit 0 before the user drops the initial ref, so as long as we
29 * convert to non percpu mode before the initial ref is dropped everything
37 #define PERCPU_COUNT_BIAS (1LU << (BITS_PER_LONG - 1))
42 static unsigned long __percpu *percpu_count_ptr(struct percpu_ref *ref) in percpu_count_ptr() argument
45 (ref->percpu_count_ptr & ~__PERCPU_REF_ATOMIC_DEAD); in percpu_count_ptr()
49 * percpu_ref_init - initialize a percpu refcount
50 * @ref: percpu_ref to initialize
55 * Initializes @ref. @ref starts out in percpu mode with a refcount of 1 unless
60 * Note that @release must not sleep - it may potentially be called from RCU
63 int percpu_ref_init(struct percpu_ref *ref, percpu_ref_func_t *release, in percpu_ref_init() argument
71 ref->percpu_count_ptr = (unsigned long) in percpu_ref_init()
73 if (!ref->percpu_count_ptr) in percpu_ref_init()
74 return -ENOMEM; in percpu_ref_init()
76 data = kzalloc(sizeof(*ref->data), gfp); in percpu_ref_init()
78 free_percpu((void __percpu *)ref->percpu_count_ptr); in percpu_ref_init()
79 ref->percpu_count_ptr = 0; in percpu_ref_init()
80 return -ENOMEM; in percpu_ref_init()
83 data->force_atomic = flags & PERCPU_REF_INIT_ATOMIC; in percpu_ref_init()
84 data->allow_reinit = flags & PERCPU_REF_ALLOW_REINIT; in percpu_ref_init()
87 ref->percpu_count_ptr |= __PERCPU_REF_ATOMIC; in percpu_ref_init()
88 data->allow_reinit = true; in percpu_ref_init()
94 ref->percpu_count_ptr |= __PERCPU_REF_DEAD; in percpu_ref_init()
98 atomic_long_set(&data->count, start_count); in percpu_ref_init()
100 data->release = release; in percpu_ref_init()
101 data->confirm_switch = NULL; in percpu_ref_init()
102 data->ref = ref; in percpu_ref_init()
103 ref->data = data; in percpu_ref_init()
108 static void __percpu_ref_exit(struct percpu_ref *ref) in __percpu_ref_exit() argument
110 unsigned long __percpu *percpu_count = percpu_count_ptr(ref); in __percpu_ref_exit()
113 /* non-NULL confirm_switch indicates switching in progress */ in __percpu_ref_exit()
114 WARN_ON_ONCE(ref->data && ref->data->confirm_switch); in __percpu_ref_exit()
116 ref->percpu_count_ptr = __PERCPU_REF_ATOMIC_DEAD; in __percpu_ref_exit()
121 * percpu_ref_exit - undo percpu_ref_init()
122 * @ref: percpu_ref to exit
124 * This function exits @ref. The caller is responsible for ensuring that
125 * @ref is no longer in active use. The usual places to invoke this
126 * function from are the @ref->release() callback or in init failure path
130 void percpu_ref_exit(struct percpu_ref *ref) in percpu_ref_exit() argument
132 struct percpu_ref_data *data = ref->data; in percpu_ref_exit()
135 __percpu_ref_exit(ref); in percpu_ref_exit()
141 ref->percpu_count_ptr |= atomic_long_read(&ref->data->count) << in percpu_ref_exit()
143 ref->data = NULL; in percpu_ref_exit()
154 struct percpu_ref *ref = data->ref; in percpu_ref_call_confirm_rcu() local
156 data->confirm_switch(ref); in percpu_ref_call_confirm_rcu()
157 data->confirm_switch = NULL; in percpu_ref_call_confirm_rcu()
160 if (!data->allow_reinit) in percpu_ref_call_confirm_rcu()
161 __percpu_ref_exit(ref); in percpu_ref_call_confirm_rcu()
163 /* drop ref from percpu_ref_switch_to_atomic() */ in percpu_ref_call_confirm_rcu()
164 percpu_ref_put(ref); in percpu_ref_call_confirm_rcu()
171 struct percpu_ref *ref = data->ref; in percpu_ref_switch_to_atomic_rcu() local
172 unsigned long __percpu *percpu_count = percpu_count_ptr(ref); in percpu_ref_switch_to_atomic_rcu()
181 atomic_long_read(&data->count), count); in percpu_ref_switch_to_atomic_rcu()
185 * to &ref->count; since gets could be happening on one cpu while puts in percpu_ref_switch_to_atomic_rcu()
187 * @ref->count to hit 0 before we've got a consistent value - but the in percpu_ref_switch_to_atomic_rcu()
191 * &ref->count; we need the bias value to prevent &ref->count from in percpu_ref_switch_to_atomic_rcu()
195 atomic_long_add((long)count - PERCPU_COUNT_BIAS, &data->count); in percpu_ref_switch_to_atomic_rcu()
197 if (WARN_ONCE(atomic_long_read(&data->count) <= 0, in percpu_ref_switch_to_atomic_rcu()
198 "percpu ref (%ps) <= 0 (%ld) after switching to atomic", in percpu_ref_switch_to_atomic_rcu()
199 data->release, atomic_long_read(&data->count)) && in percpu_ref_switch_to_atomic_rcu()
205 /* @ref is viewed as dead on all CPUs, send out switch confirmation */ in percpu_ref_switch_to_atomic_rcu()
209 static void percpu_ref_noop_confirm_switch(struct percpu_ref *ref) in percpu_ref_noop_confirm_switch() argument
213 static void __percpu_ref_switch_to_atomic(struct percpu_ref *ref, in __percpu_ref_switch_to_atomic() argument
216 if (ref->percpu_count_ptr & __PERCPU_REF_ATOMIC) { in __percpu_ref_switch_to_atomic()
218 confirm_switch(ref); in __percpu_ref_switch_to_atomic()
223 ref->percpu_count_ptr |= __PERCPU_REF_ATOMIC; in __percpu_ref_switch_to_atomic()
226 * Non-NULL ->confirm_switch is used to indicate that switching is in __percpu_ref_switch_to_atomic()
229 ref->data->confirm_switch = confirm_switch ?: in __percpu_ref_switch_to_atomic()
232 percpu_ref_get(ref); /* put after confirmation */ in __percpu_ref_switch_to_atomic()
233 call_rcu_hurry(&ref->data->rcu, in __percpu_ref_switch_to_atomic()
237 static void __percpu_ref_switch_to_percpu(struct percpu_ref *ref) in __percpu_ref_switch_to_percpu() argument
239 unsigned long __percpu *percpu_count = percpu_count_ptr(ref); in __percpu_ref_switch_to_percpu()
244 if (!(ref->percpu_count_ptr & __PERCPU_REF_ATOMIC)) in __percpu_ref_switch_to_percpu()
247 if (WARN_ON_ONCE(!ref->data->allow_reinit)) in __percpu_ref_switch_to_percpu()
250 atomic_long_add(PERCPU_COUNT_BIAS, &ref->data->count); in __percpu_ref_switch_to_percpu()
253 * Restore per-cpu operation. smp_store_release() is paired in __percpu_ref_switch_to_percpu()
261 smp_store_release(&ref->percpu_count_ptr, in __percpu_ref_switch_to_percpu()
262 ref->percpu_count_ptr & ~__PERCPU_REF_ATOMIC); in __percpu_ref_switch_to_percpu()
265 static void __percpu_ref_switch_mode(struct percpu_ref *ref, in __percpu_ref_switch_mode() argument
268 struct percpu_ref_data *data = ref->data; in __percpu_ref_switch_mode()
277 wait_event_lock_irq(percpu_ref_switch_waitq, !data->confirm_switch, in __percpu_ref_switch_mode()
280 if (data->force_atomic || percpu_ref_is_dying(ref)) in __percpu_ref_switch_mode()
281 __percpu_ref_switch_to_atomic(ref, confirm_switch); in __percpu_ref_switch_mode()
283 __percpu_ref_switch_to_percpu(ref); in __percpu_ref_switch_mode()
287 * percpu_ref_switch_to_atomic - switch a percpu_ref to atomic mode
288 * @ref: percpu_ref to switch to atomic mode
294 * Schedule switching of @ref to atomic mode. All its percpu counts will
299 * operations. Note that @ref will stay in atomic mode across kill/reinit
302 * This function may block if @ref is in the process of switching to atomic
303 * mode. If the caller ensures that @ref is not in the process of
306 void percpu_ref_switch_to_atomic(struct percpu_ref *ref, in percpu_ref_switch_to_atomic() argument
313 ref->data->force_atomic = true; in percpu_ref_switch_to_atomic()
314 __percpu_ref_switch_mode(ref, confirm_switch); in percpu_ref_switch_to_atomic()
321 * percpu_ref_switch_to_atomic_sync - switch a percpu_ref to atomic mode
322 * @ref: percpu_ref to switch to atomic mode
324 * Schedule switching the ref to atomic mode, and wait for the
328 void percpu_ref_switch_to_atomic_sync(struct percpu_ref *ref) in percpu_ref_switch_to_atomic_sync() argument
330 percpu_ref_switch_to_atomic(ref, NULL); in percpu_ref_switch_to_atomic_sync()
331 wait_event(percpu_ref_switch_waitq, !ref->data->confirm_switch); in percpu_ref_switch_to_atomic_sync()
336 * percpu_ref_switch_to_percpu - switch a percpu_ref to percpu mode
337 * @ref: percpu_ref to switch to percpu mode
340 * To re-use an expired ref, use percpu_ref_reinit().
342 * Switch @ref to percpu mode. This function may be invoked concurrently
345 * by PERCPU_REF_INIT_ATOMIC or percpu_ref_switch_to_atomic(). If @ref is
349 * This function may block if @ref is in the process of switching to atomic
350 * mode. If the caller ensures that @ref is not in the process of
353 void percpu_ref_switch_to_percpu(struct percpu_ref *ref) in percpu_ref_switch_to_percpu() argument
359 ref->data->force_atomic = false; in percpu_ref_switch_to_percpu()
360 __percpu_ref_switch_mode(ref, NULL); in percpu_ref_switch_to_percpu()
367 * percpu_ref_kill_and_confirm - drop the initial ref and schedule confirmation
368 * @ref: percpu_ref to kill
373 * called after @ref is seen as dead from all CPUs at which point all
378 * but it may block if @confirm_kill is specified and @ref is in the
383 void percpu_ref_kill_and_confirm(struct percpu_ref *ref, in percpu_ref_kill_and_confirm() argument
390 WARN_ONCE(percpu_ref_is_dying(ref), in percpu_ref_kill_and_confirm()
392 ref->data->release); in percpu_ref_kill_and_confirm()
394 ref->percpu_count_ptr |= __PERCPU_REF_DEAD; in percpu_ref_kill_and_confirm()
395 __percpu_ref_switch_mode(ref, confirm_kill); in percpu_ref_kill_and_confirm()
396 percpu_ref_put(ref); in percpu_ref_kill_and_confirm()
403 * percpu_ref_is_zero - test whether a percpu refcount reached zero
404 * @ref: percpu_ref to test
406 * Returns %true if @ref reached zero.
408 * This function is safe to call as long as @ref is between init and exit.
410 bool percpu_ref_is_zero(struct percpu_ref *ref) in percpu_ref_is_zero() argument
415 if (__ref_is_percpu(ref, &percpu_count)) in percpu_ref_is_zero()
420 if (ref->data) in percpu_ref_is_zero()
421 count = atomic_long_read(&ref->data->count); in percpu_ref_is_zero()
423 count = ref->percpu_count_ptr >> __PERCPU_REF_FLAG_BITS; in percpu_ref_is_zero()
431 * percpu_ref_reinit - re-initialize a percpu refcount
432 * @ref: perpcu_ref to re-initialize
434 * Re-initialize @ref so that it's in the same state as when it finished
435 * percpu_ref_init() ignoring %PERCPU_REF_INIT_DEAD. @ref must have been
438 * Note that percpu_ref_tryget[_live]() are safe to perform on @ref while
441 void percpu_ref_reinit(struct percpu_ref *ref) in percpu_ref_reinit() argument
443 WARN_ON_ONCE(!percpu_ref_is_zero(ref)); in percpu_ref_reinit()
445 percpu_ref_resurrect(ref); in percpu_ref_reinit()
450 * percpu_ref_resurrect - modify a percpu refcount from dead to live
451 * @ref: perpcu_ref to resurrect
453 * Modify @ref so that it's in the same state as before percpu_ref_kill() was
454 * called. @ref must be dead but must not yet have exited.
456 * If @ref->release() frees @ref then the caller is responsible for
457 * guaranteeing that @ref->release() does not get called while this
460 * Note that percpu_ref_tryget[_live]() are safe to perform on @ref while
463 void percpu_ref_resurrect(struct percpu_ref *ref) in percpu_ref_resurrect() argument
470 WARN_ON_ONCE(!percpu_ref_is_dying(ref)); in percpu_ref_resurrect()
471 WARN_ON_ONCE(__ref_is_percpu(ref, &percpu_count)); in percpu_ref_resurrect()
473 ref->percpu_count_ptr &= ~__PERCPU_REF_DEAD; in percpu_ref_resurrect()
474 percpu_ref_get(ref); in percpu_ref_resurrect()
475 __percpu_ref_switch_mode(ref, NULL); in percpu_ref_resurrect()