Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 75ec1afb authored by Jason A. Donenfeld's avatar Jason A. Donenfeld Committed by Greg Kroah-Hartman
Browse files

random: always wake up entropy writers after extraction 



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: default avatarEric Biggers <ebiggers@kernel.org>
Reviewed-by: default avatarEric Biggers <ebiggers@google.com>
Reviewed-by: default avatarDominik Brodowski <linux@dominikbrodowski.net>
Signed-off-by: default avatarJason A. Donenfeld <Jason@zx2c4.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 316d312f

Documentation/sysctl/kernel.txt

+42 −2
Original line number Diff line number Diff line
@@ -777,9 +777,49 @@ The kernel command line parameter printk.devkmsg= overrides this and is 
a one-time setting until next reboot: once set, it cannot be changed by

this sysctl interface anymore.



==============================================================

pty

===



See Documentation/filesystems/devpts.rst.





random

======



This is a directory, with the following entries:



* ``boot_id``: a UUID generated the first time this is retrieved, and

  unvarying after that;



* ``entropy_avail``: the pool's entropy count, in bits;



* ``poolsize``: the entropy pool size, in bits;



* ``urandom_min_reseed_secs``: obsolete (used to determine the minimum

  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. 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:



* ``add_interrupt_avg_cycles``: the average number of cycles between

  interrupts used to feed the pool;



* ``add_interrupt_avg_deviation``: the standard deviation seen on the

  number of cycles between interrupts used to feed the pool.





randomize_va_space:

randomize_va_space

==================



This option can be used to select the type of process address

space randomization that is used in the system, for architectures

drivers/char/random.c

+14 −22
Original line number Diff line number Diff line
@@ -297,12 +297,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);
@@ -790,10 +784,8 @@ static void crng_reseed(struct crng_state *crng, bool use_input_pool) 
				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);

		}

	} else {

		_extract_crng(&primary_crng, buf.block);

		_crng_backtrack_protect(&primary_crng, buf.block,
@@ -1522,7 +1514,7 @@ static unsigned int random_poll(struct file *file, poll_table *wait) 
	mask = 0;

	if (crng_ready())

		mask |= POLLIN | POLLRDNORM;

	if (input_pool.entropy_count < random_write_wakeup_bits)

	if (input_pool.entropy_count < POOL_MIN_BITS)

		mask |= POLLOUT | POLLWRNORM;

	return mask;

}
@@ -1607,7 +1599,10 @@ static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg) 
		 */

		if (!capable(CAP_SYS_ADMIN))

			return -EPERM;

		input_pool.entropy_count = 0;

		if (xchg(&input_pool.entropy_count, 0)) {

			wake_up_interruptible(&random_write_wait);

			kill_fasync(&fasync, SIGIO, POLL_OUT);

		}

		return 0;

	case RNDRESEEDCRNG:

		if (!capable(CAP_SYS_ADMIN))
@@ -1682,9 +1677,9 @@ SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int, 


#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];



/*
@@ -1723,7 +1718,6 @@ static int proc_do_uuid(struct ctl_table *table, int write, 
	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[] = {

	{
@@ -1745,9 +1739,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",
@@ -1928,13 +1920,13 @@ void add_hwgenerator_randomness(const char *buffer, size_t count, 
	}



	/* 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);