Merge branch 'net_get_random_once'

Hannes Frederic Sowa says:

====================
This series implements support for delaying the initialization of secret
keys, e.g. used for hashing, for as long as possible. This functionality
is implemented by a new macro, net_get_random_bytes.

I already used it to protect the socket hashes, the syncookie secret
(most important) and the tcp_fastopen secrets.

Changelog:
v2) Use static_keys in net_get_random_once to have as minimal impact to
    the fast-path as possible.
v3) added patch "static_key: WARN on usage before jump_label_init was called":
    Patch "x86/jump_label: expect default_nop if static_key gets enabled
    on boot-up" relaxes the checks for using static_key primitives before
    jump_label_init. So tighten them first.
v4) Update changelog on the patch "static_key: WARN on usage before
    jump_label_init was called"

Included patches:
 ipv4: split inet_ehashfn to hash functions per compilation unit
 ipv6: split inet6_ehashfn to hash functions per compilation unit
 static_key: WARN on usage before jump_label_init was called
 x86/jump_label: expect default_nop if static_key gets enabled on boot-up
 net: introduce new macro net_get_random_once
 inet: split syncookie keys for ipv4 and ipv6 and initialize with net_get_random_once
 inet: convert inet_ehash_secret and ipv6_hash_secret to net_get_random_once
 tcp: switch tcp_fastopen key generation to net_get_random_once
 net: switch net_secret key generation to net_get_random_once
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 48 insertions, 0 deletions

diff --git a/net/core/utils.c b/net/core/utils.c
index aa88e23fc87a..bf09371e19b1 100644
--- a/net/core/utils.c
+++ b/net/core/utils.c
@@ -338,3 +338,51 @@ void inet_proto_csum_replace16(__sum16 *sum, struct sk_buff *skb,
                                   csum_unfold(*sum)));
 }
 EXPORT_SYMBOL(inet_proto_csum_replace16);
+
+struct __net_random_once_work {
+        struct work_struct work;
+        struct static_key *key;
+};
+
+static void __net_random_once_deferred(struct work_struct *w)
+{
+        struct __net_random_once_work *work =
+                container_of(w, struct __net_random_once_work, work);
+        if (!static_key_enabled(work->key))
+                static_key_slow_inc(work->key);
+        kfree(work);
+}
+
+static void __net_random_once_disable_jump(struct static_key *key)
+{
+        struct __net_random_once_work *w;
+
+        w = kmalloc(sizeof(*w), GFP_ATOMIC);
+        if (!w)
+                return;
+
+        INIT_WORK(&w->work, __net_random_once_deferred);
+        w->key = key;
+        schedule_work(&w->work);
+}
+
+bool __net_get_random_once(void *buf, int nbytes, bool *done,
+                           struct static_key *done_key)
+{
+        static DEFINE_SPINLOCK(lock);
+
+        spin_lock_bh(&lock);
+        if (*done) {
+                spin_unlock_bh(&lock);
+                return false;
+        }
+
+        get_random_bytes(buf, nbytes);
+        *done = true;
+        spin_unlock_bh(&lock);
+
+        __net_random_once_disable_jump(done_key);
+
+        return true;
+}
+EXPORT_SYMBOL(__net_get_random_once);