linux-master/lib/percpu-refcount.c

13  * don't try to detect the ref hitting 0 - which means that get/put can just
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
42 static unsigned long __percpu *percpu_count_ptr(struct percpu_ref *ref)
45 		(ref->percpu_count_ptr & ~__PERCPU_REF_ATOMIC_DEAD);
50  * @ref: percpu_ref to initialize
55  * Initializes @ref.  @ref starts out in percpu mode with a refcount of 1 unless
63 int percpu_ref_init(struct percpu_ref *ref, percpu_ref_func_t *release,
71 	ref->percpu_count_ptr = (unsigned long)
73 	if (!ref->percpu_count_ptr)
76 	data = kzalloc(sizeof(*ref->data), gfp);
78 		free_percpu((void __percpu *)ref->percpu_count_ptr);
79 		ref->percpu_count_ptr = 0;
87 		ref->percpu_count_ptr |= __PERCPU_REF_ATOMIC;
94 		ref->percpu_count_ptr |= __PERCPU_REF_DEAD;
102 	data->ref = ref;
103 	ref->data = data;
108 static void __percpu_ref_exit(struct percpu_ref *ref)
110 	unsigned long __percpu *percpu_count = percpu_count_ptr(ref);
114 		WARN_ON_ONCE(ref->data && ref->data->confirm_switch);
116 		ref->percpu_count_ptr = __PERCPU_REF_ATOMIC_DEAD;
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)
132 	struct percpu_ref_data *data = ref->data;
135 	__percpu_ref_exit(ref);
141 	ref->percpu_count_ptr |= atomic_long_read(&ref->data->count) <<
143 	ref->data = NULL;
154 	struct percpu_ref *ref = data->ref;
156 	data->confirm_switch(ref);
161 		__percpu_ref_exit(ref);
163 	/* drop ref from percpu_ref_switch_to_atomic() */
164 	percpu_ref_put(ref);
171 	struct percpu_ref *ref = data->ref;
172 	unsigned long __percpu *percpu_count = percpu_count_ptr(ref);
185 	 * to &ref->count; since gets could be happening on one cpu while puts
187 	 * @ref->count to hit 0 before we've got a consistent value - but the
191 	 * &ref->count; we need the bias value to prevent &ref->count from
198 		      "percpu ref (%ps) <= 0 (%ld) after switching to atomic",
205 	/* @ref is viewed as dead on all CPUs, send out switch confirmation */
209 static void percpu_ref_noop_confirm_switch(struct percpu_ref *ref)
213 static void __percpu_ref_switch_to_atomic(struct percpu_ref *ref,
216 	if (ref->percpu_count_ptr & __PERCPU_REF_ATOMIC) {
218 			confirm_switch(ref);
223 	ref->percpu_count_ptr |= __PERCPU_REF_ATOMIC;
229 	ref->data->confirm_switch = confirm_switch ?:
232 	percpu_ref_get(ref);	/* put after confirmation */
233 	call_rcu_hurry(&ref->data->rcu,
237 static void __percpu_ref_switch_to_percpu(struct percpu_ref *ref)
239 	unsigned long __percpu *percpu_count = percpu_count_ptr(ref);
244 	if (!(ref->percpu_count_ptr & __PERCPU_REF_ATOMIC))
247 	if (WARN_ON_ONCE(!ref->data->allow_reinit))
250 	atomic_long_add(PERCPU_COUNT_BIAS, &ref->data->count);
261 	smp_store_release(&ref->percpu_count_ptr,
262 			  ref->percpu_count_ptr & ~__PERCPU_REF_ATOMIC);
265 static void __percpu_ref_switch_mode(struct percpu_ref *ref,
268 	struct percpu_ref_data *data = ref->data;
280 	if (data->force_atomic || percpu_ref_is_dying(ref))
281 		__percpu_ref_switch_to_atomic(ref, confirm_switch);
283 		__percpu_ref_switch_to_percpu(ref);
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,
313 	ref->data->force_atomic = true;
314 	__percpu_ref_switch_mode(ref, confirm_switch);
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)
330 	percpu_ref_switch_to_atomic(ref, NULL);
331 	wait_event(percpu_ref_switch_waitq, !ref->data->confirm_switch);
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)
359 	ref->data->force_atomic = false;
360 	__percpu_ref_switch_mode(ref, NULL);
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,
390 	WARN_ONCE(percpu_ref_is_dying(ref),
392 		  ref->data->release);
394 	ref->percpu_count_ptr |= __PERCPU_REF_DEAD;
395 	__percpu_ref_switch_mode(ref, confirm_kill);
396 	percpu_ref_put(ref);
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)
415 	if (__ref_is_percpu(ref, &percpu_count))
420 	if (ref->data)
421 		count = atomic_long_read(&ref->data->count);
423 		count = ref->percpu_count_ptr >> __PERCPU_REF_FLAG_BITS;
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)
443 	WARN_ON_ONCE(!percpu_ref_is_zero(ref));
445 	percpu_ref_resurrect(ref);
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)
470 	WARN_ON_ONCE(!percpu_ref_is_dying(ref));
471 	WARN_ON_ONCE(__ref_is_percpu(ref, &percpu_count));
473 	ref->percpu_count_ptr &= ~__PERCPU_REF_DEAD;
474 	percpu_ref_get(ref);
475 	__percpu_ref_switch_mode(ref, NULL);