Commit 2a4187f4 authored by Jason A. Donenfeld's avatar Jason A. Donenfeld Committed by Jakub Kicinski
Browse files

once: rename _SLOW to _SLEEPABLE 



The _SLOW designation wasn't really descriptive of anything. This is
meant to be called from process context when it's possible to sleep. So
name this more aptly _SLEEPABLE, which better fits its intended use.

Fixes: 62c07983 ("once: add DO_ONCE_SLOW() for sleepable contexts")
Cc: Christophe Leroy <christophe.leroy@csgroup.eu>
Signed-off-by: default avatarJason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: default avatarEric Dumazet <edumazet@google.com>
Link: https://lore.kernel.org/r/20221003181413.1221968-1-Jason@zx2c4.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 33183489

include/linux/once.h

+19 −19
Original line number Diff line number Diff line
@@ -13,8 +13,8 @@ void __do_once_done(bool *done, struct static_key_true *once_key, 
		    unsigned long *flags, struct module *mod);



/* Variant for process contexts only. */

bool __do_once_slow_start(bool *done);

void __do_once_slow_done(bool *done, struct static_key_true *once_key,

bool __do_once_sleepable_start(bool *done);

void __do_once_sleepable_done(bool *done, struct static_key_true *once_key,

			      struct module *mod);



/* Call a function exactly once. The idea of DO_ONCE() is to perform
@@ -61,16 +61,16 @@ void __do_once_slow_done(bool *done, struct static_key_true *once_key, 
	})



/* Variant of DO_ONCE() for process/sleepable contexts. */

#define DO_ONCE_SLOW(func, ...)						     \

#define DO_ONCE_SLEEPABLE(func, ...)						\

	({									\

		bool ___ret = false;						\

		static bool __section(".data.once") ___done = false;		\

		static DEFINE_STATIC_KEY_TRUE(___once_key);			\

		if (static_branch_unlikely(&___once_key)) {			\

			___ret = __do_once_slow_start(&___done);	     \

			___ret = __do_once_sleepable_start(&___done);		\

			if (unlikely(___ret)) {					\

				func(__VA_ARGS__);				\

				__do_once_slow_done(&___done, &___once_key,  \

				__do_once_sleepable_done(&___done, &___once_key,\

						    THIS_MODULE);		\

			}							\

		}								\
@@ -80,7 +80,7 @@ void __do_once_slow_done(bool *done, struct static_key_true *once_key, 
#define get_random_once(buf, nbytes)					     \

	DO_ONCE(get_random_bytes, (buf), (nbytes))



#define get_random_slow_once(buf, nbytes)				     \

	DO_ONCE_SLOW(get_random_bytes, (buf), (nbytes))

#define get_random_sleepable_once(buf, nbytes)				     \

	DO_ONCE_SLEEPABLE(get_random_bytes, (buf), (nbytes))



#endif /* _LINUX_ONCE_H */

lib/once.c

+5 −5
Original line number Diff line number Diff line
@@ -69,7 +69,7 @@ EXPORT_SYMBOL(__do_once_done); 


static DEFINE_MUTEX(once_mutex);



bool __do_once_slow_start(bool *done)

bool __do_once_sleepable_start(bool *done)

	__acquires(once_mutex)

{

	mutex_lock(&once_mutex);
@@ -77,7 +77,7 @@ bool __do_once_slow_start(bool *done) 
		mutex_unlock(&once_mutex);

		/* Keep sparse happy by restoring an even lock count on

		 * this mutex. In case we return here, we don't call into

		 * __do_once_done but return early in the DO_ONCE_SLOW() macro.

		 * __do_once_done but return early in the DO_ONCE_SLEEPABLE() macro.

		 */

		__acquire(once_mutex);

		return false;
@@ -85,9 +85,9 @@ bool __do_once_slow_start(bool *done) 


	return true;

}

EXPORT_SYMBOL(__do_once_slow_start);

EXPORT_SYMBOL(__do_once_sleepable_start);



void __do_once_slow_done(bool *done, struct static_key_true *once_key,

void __do_once_sleepable_done(bool *done, struct static_key_true *once_key,

			 struct module *mod)

	__releases(once_mutex)

{
@@ -95,4 +95,4 @@ void __do_once_slow_done(bool *done, struct static_key_true *once_key, 
	mutex_unlock(&once_mutex);

	once_disable_jump(once_key, mod);

}

EXPORT_SYMBOL(__do_once_slow_done);
 
EXPORT_SYMBOL(__do_once_sleepable_done);

net/ipv4/inet_hashtables.c

+2 −2
Original line number Diff line number Diff line
@@ -958,7 +958,7 @@ int __inet_hash_connect(struct inet_timewait_death_row *death_row, 
	if (likely(remaining > 1))

		remaining &= ~1U;



	get_random_slow_once(table_perturb,

	get_random_sleepable_once(table_perturb,

				  INET_TABLE_PERTURB_SIZE * sizeof(*table_perturb));

	index = port_offset & (INET_TABLE_PERTURB_SIZE - 1);