lkml.org 
[lkml]   [2022]   [May]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.10 059/163] random: always wake up entropy writers after extraction
    Date
    From: "Jason A. Donenfeld" <Jason@zx2c4.com>

    commit 489c7fc44b5740d377e8cfdbf0851036e493af00 upstream.

    Now that POOL_BITS == POOL_MIN_BITS, we must unconditionally wake up
    entropy writers after every extraction. Therefore there's no point of
    write_wakeup_threshold, so we can move it to the dustbin of unused
    compatibility sysctls. While we're at it, we can fix a small comparison
    where we were waking up after <= min rather than < min.

    Cc: Theodore Ts'o <tytso@mit.edu>
    Suggested-by: Eric Biggers <ebiggers@kernel.org>
    Reviewed-by: Eric Biggers <ebiggers@google.com>
    Reviewed-by: Dominik Brodowski <linux@dominikbrodowski.net>
    Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
    ---
    Documentation/admin-guide/sysctl/kernel.rst | 7 ++++-
    drivers/char/random.c | 33 +++++++++-------------------
    2 files changed, 16 insertions(+), 24 deletions(-)

    --- a/Documentation/admin-guide/sysctl/kernel.rst
    +++ b/Documentation/admin-guide/sysctl/kernel.rst
    @@ -1011,14 +1011,17 @@ This is a directory, with the following
    * ``poolsize``: the entropy pool size, in bits;

    * ``urandom_min_reseed_secs``: obsolete (used to determine the minimum
    - number of seconds between urandom pool reseeding).
    + number of seconds between urandom pool reseeding). This file is
    + writable for compatibility purposes, but writing to it has no effect
    + on any RNG behavior.

    * ``uuid``: a UUID generated every time this is retrieved (this can
    thus be used to generate UUIDs at will);

    * ``write_wakeup_threshold``: when the entropy count drops below this
    (as a number of bits), processes waiting to write to ``/dev/random``
    - are woken up.
    + are woken up. This file is writable for compatibility purposes, but
    + writing to it has no effect on any RNG behavior.

    If ``drivers/char/random.c`` is built with ``ADD_INTERRUPT_BENCH``
    defined, these additional entries are present:
    --- a/drivers/char/random.c
    +++ b/drivers/char/random.c
    @@ -296,12 +296,6 @@ enum {
    */
    static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
    static struct fasync_struct *fasync;
    -/*
    - * If the entropy count falls under this number of bits, then we
    - * should wake up processes which are selecting or polling on write
    - * access to /dev/random.
    - */
    -static int random_write_wakeup_bits = POOL_MIN_BITS;

    static DEFINE_SPINLOCK(random_ready_list_lock);
    static LIST_HEAD(random_ready_list);
    @@ -739,10 +733,8 @@ static void crng_reseed(struct crng_stat
    return;
    } while (cmpxchg(&input_pool.entropy_count, entropy_count, 0) != entropy_count);
    extract_entropy(buf.key, sizeof(buf.key));
    - if (random_write_wakeup_bits) {
    - wake_up_interruptible(&random_write_wait);
    - kill_fasync(&fasync, SIGIO, POLL_OUT);
    - }
    + wake_up_interruptible(&random_write_wait);
    + kill_fasync(&fasync, SIGIO, POLL_OUT);
    } else {
    _extract_crng(&primary_crng, buf.block);
    _crng_backtrack_protect(&primary_crng, buf.block,
    @@ -1471,7 +1463,7 @@ static __poll_t random_poll(struct file
    mask = 0;
    if (crng_ready())
    mask |= EPOLLIN | EPOLLRDNORM;
    - if (input_pool.entropy_count < random_write_wakeup_bits)
    + if (input_pool.entropy_count < POOL_MIN_BITS)
    mask |= EPOLLOUT | EPOLLWRNORM;
    return mask;
    }
    @@ -1556,7 +1548,7 @@ static long random_ioctl(struct file *f,
    */
    if (!capable(CAP_SYS_ADMIN))
    return -EPERM;
    - if (xchg(&input_pool.entropy_count, 0) && random_write_wakeup_bits) {
    + if (xchg(&input_pool.entropy_count, 0)) {
    wake_up_interruptible(&random_write_wait);
    kill_fasync(&fasync, SIGIO, POLL_OUT);
    }
    @@ -1636,9 +1628,9 @@ SYSCALL_DEFINE3(getrandom, char __user *

    #include <linux/sysctl.h>

    -static int min_write_thresh;
    -static int max_write_thresh = POOL_BITS;
    static int random_min_urandom_seed = 60;
    +static int random_write_wakeup_bits = POOL_MIN_BITS;
    +static int sysctl_poolsize = POOL_BITS;
    static char sysctl_bootid[16];

    /*
    @@ -1677,7 +1669,6 @@ static int proc_do_uuid(struct ctl_table
    return proc_dostring(&fake_table, write, buffer, lenp, ppos);
    }

    -static int sysctl_poolsize = POOL_BITS;
    extern struct ctl_table random_table[];
    struct ctl_table random_table[] = {
    {
    @@ -1699,9 +1690,7 @@ struct ctl_table random_table[] = {
    .data = &random_write_wakeup_bits,
    .maxlen = sizeof(int),
    .mode = 0644,
    - .proc_handler = proc_dointvec_minmax,
    - .extra1 = &min_write_thresh,
    - .extra2 = &max_write_thresh,
    + .proc_handler = proc_dointvec,
    },
    {
    .procname = "urandom_min_reseed_secs",
    @@ -1882,13 +1871,13 @@ void add_hwgenerator_randomness(const ch
    }

    /* Throttle writing if we're above the trickle threshold.
    - * We'll be woken up again once below random_write_wakeup_thresh,
    - * when the calling thread is about to terminate, or once
    - * CRNG_RESEED_INTERVAL has lapsed.
    + * We'll be woken up again once below POOL_MIN_BITS, when
    + * the calling thread is about to terminate, or once
    + * CRNG_RESEED_INTERVAL has elapsed.
    */
    wait_event_interruptible_timeout(random_write_wait,
    !system_wq || kthread_should_stop() ||
    - input_pool.entropy_count <= random_write_wakeup_bits,
    + input_pool.entropy_count < POOL_MIN_BITS,
    CRNG_RESEED_INTERVAL);
    mix_pool_bytes(buffer, count);
    credit_entropy_bits(entropy);

    \
     
     \ /
      Last update: 2022-05-27 13:56    [W:4.239 / U:0.412 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site