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: 4021e1a2ce29 ("once: add DO_ONCE_SLOW() for sleepable contexts")
Cc: Christophe Leroy <christophe.leroy@csgroup.eu>
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Link: https://lore.kernel.org/r/20221003181413.1221968-1-Jason@zx2c4.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/include/linux/once.h b/include/linux/once.h
index 176ab75b42df740a738d04d8480821a0b3b65ba9..bc714d414448a7ab982f14d4ab76512170a4689f 100644 (file)
--- a/include/linux/once.h
+++ b/include/linux/once.h
@@ -13,9 +13,9 @@ 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,
-                        struct module *mod);
+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
  * a function call such as initialization of random seeds, etc, only
@@ -61,26 +61,26 @@ 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, ...)                                                     \
-       ({                                                                   \
-               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);             \
-                       if (unlikely(___ret)) {                              \
-                               func(__VA_ARGS__);                           \
-                               __do_once_slow_done(&___done, &___once_key,  \
-                                                   THIS_MODULE);            \
-                       }                                                    \
-               }                                                            \
-               ___ret;                                                      \
+#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_sleepable_start(&___done);           \
+                       if (unlikely(___ret)) {                                 \
+                               func(__VA_ARGS__);                              \
+                               __do_once_sleepable_done(&___done, &___once_key,\
+                                                   THIS_MODULE);               \
+                       }                                                       \
+               }                                                               \
+               ___ret;                                                         \
        })
 
 #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 */

diff --git a/lib/once.c b/lib/once.c
index 351f66aad310a47f17d0636da0ed5b2b4460522d..2c306f0e891e87ce033fbea2e1d431c3ea6ce4f6 100644 (file)
--- a/lib/once.c
+++ b/lib/once.c
@@ -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);

diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index dc1c5629cd0d61716d6d99131c57b49717785709..a0ad34e4f044b7b12ef3fbcdc4eed37ce76dbe46 100644 (file)
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -958,8 +958,8 @@ int __inet_hash_connect(struct inet_timewait_death_row *death_row,
        if (likely(remaining > 1))
                remaining &= ~1U;
 
-       get_random_slow_once(table_perturb,
-                            INET_TABLE_PERTURB_SIZE * sizeof(*table_perturb));
+       get_random_sleepable_once(table_perturb,
+                                 INET_TABLE_PERTURB_SIZE * sizeof(*table_perturb));
        index = port_offset & (INET_TABLE_PERTURB_SIZE - 1);
 
        offset = READ_ONCE(table_perturb[index]) + (port_offset >> 32);