This is a note to let you know that I've just added the patch titled random: use proper return types on get_random_{int,long}_wait() to the 4.14-stable tree which can be found at: http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary The filename of the patch is: random-use-proper-return-types-on-get_random_-int-long-_wait.patch and it can be found in the queue-4.14 subdirectory. If you, or anyone else, feels it should not be added to the stable tree, please let <stable@xxxxxxxxxxxxxxx> know about it. >From foo@baz Thu Jun 16 07:08:33 PM CEST 2022 From: "Jason A. Donenfeld" <Jason@xxxxxxxxx> Date: Fri, 13 May 2022 12:32:23 +0200 Subject: random: use proper return types on get_random_{int,long}_wait() From: "Jason A. Donenfeld" <Jason@xxxxxxxxx> commit 7c3a8a1db5e03d02cc0abb3357a84b8b326dfac3 upstream. Before these were returning signed values, but the API is intended to be used with unsigned values. Signed-off-by: Jason A. Donenfeld <Jason@xxxxxxxxx> Signed-off-by: Greg Kroah-Hartman <gregkh@xxxxxxxxxxxxxxxxxxx> --- drivers/char/random.c | 195 +++++++++++++++++++++++-------------------------- include/linux/random.h | 24 +++--- 2 files changed, 107 insertions(+), 112 deletions(-) --- a/drivers/char/random.c +++ b/drivers/char/random.c @@ -210,7 +210,7 @@ static void _warn_unseeded_randomness(co * * There are a few exported interfaces for use by other drivers: * - * void get_random_bytes(void *buf, size_t nbytes) + * void get_random_bytes(void *buf, size_t len) * u32 get_random_u32() * u64 get_random_u64() * unsigned int get_random_int() @@ -249,7 +249,7 @@ static DEFINE_PER_CPU(struct crng, crngs }; /* Used by crng_reseed() and crng_make_state() to extract a new seed from the input pool. */ -static void extract_entropy(void *buf, size_t nbytes); +static void extract_entropy(void *buf, size_t len); /* This extracts a new crng key from the input pool. */ static void crng_reseed(void) @@ -403,24 +403,24 @@ static void crng_make_state(u32 chacha_s local_irq_restore(flags); } -static void _get_random_bytes(void *buf, size_t nbytes) +static void _get_random_bytes(void *buf, size_t len) { u32 chacha_state[CHACHA20_BLOCK_SIZE / sizeof(u32)]; u8 tmp[CHACHA20_BLOCK_SIZE]; - size_t len; + size_t first_block_len; - if (!nbytes) + if (!len) return; - len = min_t(size_t, 32, nbytes); - crng_make_state(chacha_state, buf, len); - nbytes -= len; - buf += len; + first_block_len = min_t(size_t, 32, len); + crng_make_state(chacha_state, buf, first_block_len); + len -= first_block_len; + buf += first_block_len; - while (nbytes) { - if (nbytes < CHACHA20_BLOCK_SIZE) { + while (len) { + if (len < CHACHA20_BLOCK_SIZE) { chacha20_block(chacha_state, tmp); - memcpy(buf, tmp, nbytes); + memcpy(buf, tmp, len); memzero_explicit(tmp, sizeof(tmp)); break; } @@ -428,7 +428,7 @@ static void _get_random_bytes(void *buf, chacha20_block(chacha_state, buf); if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; - nbytes -= CHACHA20_BLOCK_SIZE; + len -= CHACHA20_BLOCK_SIZE; buf += CHACHA20_BLOCK_SIZE; } @@ -445,20 +445,20 @@ static void _get_random_bytes(void *buf, * wait_for_random_bytes() should be called and return 0 at least once * at any point prior. */ -void get_random_bytes(void *buf, size_t nbytes) +void get_random_bytes(void *buf, size_t len) { warn_unseeded_randomness(); - _get_random_bytes(buf, nbytes); + _get_random_bytes(buf, len); } EXPORT_SYMBOL(get_random_bytes); -static ssize_t get_random_bytes_user(void __user *buf, size_t nbytes) +static ssize_t get_random_bytes_user(void __user *ubuf, size_t len) { - size_t len, left, ret = 0; + size_t block_len, left, ret = 0; u32 chacha_state[CHACHA20_BLOCK_SIZE / sizeof(u32)]; u8 output[CHACHA20_BLOCK_SIZE]; - if (!nbytes) + if (!len) return 0; /* @@ -472,8 +472,8 @@ static ssize_t get_random_bytes_user(voi * use chacha_state after, so we can simply return those bytes to * the user directly. */ - if (nbytes <= CHACHA20_KEY_SIZE) { - ret = nbytes - copy_to_user(buf, &chacha_state[4], nbytes); + if (len <= CHACHA20_KEY_SIZE) { + ret = len - copy_to_user(ubuf, &chacha_state[4], len); goto out_zero_chacha; } @@ -482,17 +482,17 @@ static ssize_t get_random_bytes_user(voi if (unlikely(chacha_state[12] == 0)) ++chacha_state[13]; - len = min_t(size_t, nbytes, CHACHA20_BLOCK_SIZE); - left = copy_to_user(buf, output, len); + block_len = min_t(size_t, len, CHACHA20_BLOCK_SIZE); + left = copy_to_user(ubuf, output, block_len); if (left) { - ret += len - left; + ret += block_len - left; break; } - buf += len; - ret += len; - nbytes -= len; - if (!nbytes) + ubuf += block_len; + ret += block_len; + len -= block_len; + if (!len) break; BUILD_BUG_ON(PAGE_SIZE % CHACHA20_BLOCK_SIZE != 0); @@ -663,24 +663,24 @@ unsigned long randomize_page(unsigned lo * use. Use get_random_bytes() instead. It returns the number of * bytes filled in. */ -size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes) +size_t __must_check get_random_bytes_arch(void *buf, size_t len) { - size_t left = nbytes; + size_t left = len; u8 *p = buf; while (left) { unsigned long v; - size_t chunk = min_t(size_t, left, sizeof(unsigned long)); + size_t block_len = min_t(size_t, left, sizeof(unsigned long)); if (!arch_get_random_long(&v)) break; - memcpy(p, &v, chunk); - p += chunk; - left -= chunk; + memcpy(p, &v, block_len); + p += block_len; + left -= block_len; } - return nbytes - left; + return len - left; } EXPORT_SYMBOL(get_random_bytes_arch); @@ -691,15 +691,15 @@ EXPORT_SYMBOL(get_random_bytes_arch); * * Callers may add entropy via: * - * static void mix_pool_bytes(const void *in, size_t nbytes) + * static void mix_pool_bytes(const void *buf, size_t len) * * After which, if added entropy should be credited: * - * static void credit_init_bits(size_t nbits) + * static void credit_init_bits(size_t bits) * * Finally, extract entropy via: * - * static void extract_entropy(void *buf, size_t nbytes) + * static void extract_entropy(void *buf, size_t len) * **********************************************************************/ @@ -721,9 +721,9 @@ static struct { .lock = __SPIN_LOCK_UNLOCKED(input_pool.lock), }; -static void _mix_pool_bytes(const void *in, size_t nbytes) +static void _mix_pool_bytes(const void *buf, size_t len) { - blake2s_update(&input_pool.hash, in, nbytes); + blake2s_update(&input_pool.hash, buf, len); } /* @@ -731,12 +731,12 @@ static void _mix_pool_bytes(const void * * update the initialization bit counter; the caller should call * credit_init_bits if this is appropriate. */ -static void mix_pool_bytes(const void *in, size_t nbytes) +static void mix_pool_bytes(const void *buf, size_t len) { unsigned long flags; spin_lock_irqsave(&input_pool.lock, flags); - _mix_pool_bytes(in, nbytes); + _mix_pool_bytes(buf, len); spin_unlock_irqrestore(&input_pool.lock, flags); } @@ -744,7 +744,7 @@ static void mix_pool_bytes(const void *i * This is an HKDF-like construction for using the hashed collected entropy * as a PRF key, that's then expanded block-by-block. */ -static void extract_entropy(void *buf, size_t nbytes) +static void extract_entropy(void *buf, size_t len) { unsigned long flags; u8 seed[BLAKE2S_HASH_SIZE], next_key[BLAKE2S_HASH_SIZE]; @@ -773,12 +773,12 @@ static void extract_entropy(void *buf, s spin_unlock_irqrestore(&input_pool.lock, flags); memzero_explicit(next_key, sizeof(next_key)); - while (nbytes) { - i = min_t(size_t, nbytes, BLAKE2S_HASH_SIZE); + while (len) { + i = min_t(size_t, len, BLAKE2S_HASH_SIZE); /* output = HASHPRF(seed, RDSEED || ++counter) */ ++block.counter; blake2s(buf, (u8 *)&block, seed, i, sizeof(block), sizeof(seed)); - nbytes -= i; + len -= i; buf += i; } @@ -786,16 +786,16 @@ static void extract_entropy(void *buf, s memzero_explicit(&block, sizeof(block)); } -static void credit_init_bits(size_t nbits) +static void credit_init_bits(size_t bits) { static struct execute_work set_ready; unsigned int new, orig, add; unsigned long flags; - if (crng_ready() || !nbits) + if (crng_ready() || !bits) return; - add = min_t(size_t, nbits, POOL_BITS); + add = min_t(size_t, bits, POOL_BITS); do { orig = READ_ONCE(input_pool.init_bits); @@ -831,13 +831,11 @@ static void credit_init_bits(size_t nbit * The following exported functions are used for pushing entropy into * the above entropy accumulation routines: * - * void add_device_randomness(const void *buf, size_t size); - * void add_hwgenerator_randomness(const void *buffer, size_t count, - * size_t entropy); - * void add_bootloader_randomness(const void *buf, size_t size); + * void add_device_randomness(const void *buf, size_t len); + * void add_hwgenerator_randomness(const void *buf, size_t len, size_t entropy); + * void add_bootloader_randomness(const void *buf, size_t len); * void add_interrupt_randomness(int irq); - * void add_input_randomness(unsigned int type, unsigned int code, - * unsigned int value); + * void add_input_randomness(unsigned int type, unsigned int code, unsigned int value); * void add_disk_randomness(struct gendisk *disk); * * add_device_randomness() adds data to the input pool that @@ -901,7 +899,7 @@ int __init random_init(const char *comma { ktime_t now = ktime_get_real(); unsigned int i, arch_bytes; - unsigned long rv; + unsigned long entropy; #if defined(LATENT_ENTROPY_PLUGIN) static const u8 compiletime_seed[BLAKE2S_BLOCK_SIZE] __initconst __latent_entropy; @@ -909,13 +907,13 @@ int __init random_init(const char *comma #endif for (i = 0, arch_bytes = BLAKE2S_BLOCK_SIZE; - i < BLAKE2S_BLOCK_SIZE; i += sizeof(rv)) { - if (!arch_get_random_seed_long_early(&rv) && - !arch_get_random_long_early(&rv)) { - rv = random_get_entropy(); - arch_bytes -= sizeof(rv); + i < BLAKE2S_BLOCK_SIZE; i += sizeof(entropy)) { + if (!arch_get_random_seed_long_early(&entropy) && + !arch_get_random_long_early(&entropy)) { + entropy = random_get_entropy(); + arch_bytes -= sizeof(entropy); } - _mix_pool_bytes(&rv, sizeof(rv)); + _mix_pool_bytes(&entropy, sizeof(entropy)); } _mix_pool_bytes(&now, sizeof(now)); _mix_pool_bytes(utsname(), sizeof(*(utsname()))); @@ -938,14 +936,14 @@ int __init random_init(const char *comma * the entropy pool having similar initial state across largely * identical devices. */ -void add_device_randomness(const void *buf, size_t size) +void add_device_randomness(const void *buf, size_t len) { unsigned long entropy = random_get_entropy(); unsigned long flags; spin_lock_irqsave(&input_pool.lock, flags); _mix_pool_bytes(&entropy, sizeof(entropy)); - _mix_pool_bytes(buf, size); + _mix_pool_bytes(buf, len); spin_unlock_irqrestore(&input_pool.lock, flags); } EXPORT_SYMBOL(add_device_randomness); @@ -955,10 +953,9 @@ EXPORT_SYMBOL(add_device_randomness); * Those devices may produce endless random bits and will be throttled * when our pool is full. */ -void add_hwgenerator_randomness(const void *buffer, size_t count, - size_t entropy) +void add_hwgenerator_randomness(const void *buf, size_t len, size_t entropy) { - mix_pool_bytes(buffer, count); + mix_pool_bytes(buf, len); credit_init_bits(entropy); /* @@ -974,11 +971,11 @@ EXPORT_SYMBOL_GPL(add_hwgenerator_random * Handle random seed passed by bootloader, and credit it if * CONFIG_RANDOM_TRUST_BOOTLOADER is set. */ -void add_bootloader_randomness(const void *buf, size_t size) +void add_bootloader_randomness(const void *buf, size_t len) { - mix_pool_bytes(buf, size); + mix_pool_bytes(buf, len); if (trust_bootloader) - credit_init_bits(size * 8); + credit_init_bits(len * 8); } EXPORT_SYMBOL_GPL(add_bootloader_randomness); @@ -1178,8 +1175,7 @@ static void add_timer_randomness(struct credit_init_bits(bits); } -void add_input_randomness(unsigned int type, unsigned int code, - unsigned int value) +void add_input_randomness(unsigned int type, unsigned int code, unsigned int value) { static unsigned char last_value; static struct timer_rand_state input_timer_state = { INITIAL_JIFFIES }; @@ -1298,8 +1294,7 @@ static void try_to_generate_entropy(void * **********************************************************************/ -SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int, - flags) +SYSCALL_DEFINE3(getrandom, char __user *, ubuf, size_t, len, unsigned int, flags) { if (flags & ~(GRND_NONBLOCK | GRND_RANDOM | GRND_INSECURE)) return -EINVAL; @@ -1311,8 +1306,8 @@ SYSCALL_DEFINE3(getrandom, char __user * if ((flags & (GRND_INSECURE | GRND_RANDOM)) == (GRND_INSECURE | GRND_RANDOM)) return -EINVAL; - if (count > INT_MAX) - count = INT_MAX; + if (len > INT_MAX) + len = INT_MAX; if (!crng_ready() && !(flags & GRND_INSECURE)) { int ret; @@ -1323,7 +1318,7 @@ SYSCALL_DEFINE3(getrandom, char __user * if (unlikely(ret)) return ret; } - return get_random_bytes_user(buf, count); + return get_random_bytes_user(ubuf, len); } static unsigned int random_poll(struct file *file, poll_table *wait) @@ -1332,21 +1327,21 @@ static unsigned int random_poll(struct f return crng_ready() ? POLLIN | POLLRDNORM : POLLOUT | POLLWRNORM; } -static int write_pool(const char __user *ubuf, size_t count) +static int write_pool(const char __user *ubuf, size_t len) { - size_t len; + size_t block_len; int ret = 0; u8 block[BLAKE2S_BLOCK_SIZE]; - while (count) { - len = min(count, sizeof(block)); - if (copy_from_user(block, ubuf, len)) { + while (len) { + block_len = min(len, sizeof(block)); + if (copy_from_user(block, ubuf, block_len)) { ret = -EFAULT; goto out; } - count -= len; - ubuf += len; - mix_pool_bytes(block, len); + len -= block_len; + ubuf += block_len; + mix_pool_bytes(block, block_len); cond_resched(); } @@ -1355,20 +1350,20 @@ out: return ret; } -static ssize_t random_write(struct file *file, const char __user *buffer, - size_t count, loff_t *ppos) +static ssize_t random_write(struct file *file, const char __user *ubuf, + size_t len, loff_t *ppos) { int ret; - ret = write_pool(buffer, count); + ret = write_pool(ubuf, len); if (ret) return ret; - return (ssize_t)count; + return (ssize_t)len; } -static ssize_t urandom_read(struct file *file, char __user *buf, size_t nbytes, - loff_t *ppos) +static ssize_t urandom_read(struct file *file, char __user *ubuf, + size_t len, loff_t *ppos) { static int maxwarn = 10; @@ -1378,22 +1373,22 @@ static ssize_t urandom_read(struct file else if (ratelimit_disable || __ratelimit(&urandom_warning)) { --maxwarn; pr_notice("%s: uninitialized urandom read (%zd bytes read)\n", - current->comm, nbytes); + current->comm, len); } } - return get_random_bytes_user(buf, nbytes); + return get_random_bytes_user(ubuf, len); } -static ssize_t random_read(struct file *file, char __user *buf, size_t nbytes, - loff_t *ppos) +static ssize_t random_read(struct file *file, char __user *ubuf, + size_t len, loff_t *ppos) { int ret; ret = wait_for_random_bytes(); if (ret != 0) return ret; - return get_random_bytes_user(buf, nbytes); + return get_random_bytes_user(ubuf, len); } static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg) @@ -1516,8 +1511,8 @@ static u8 sysctl_bootid[UUID_SIZE]; * UUID. The difference is in whether table->data is NULL; if it is, * then a new UUID is generated and returned to the user. */ -static int proc_do_uuid(struct ctl_table *table, int write, - void __user *buffer, size_t *lenp, loff_t *ppos) +static int proc_do_uuid(struct ctl_table *table, int write, void __user *buf, + size_t *lenp, loff_t *ppos) { u8 tmp_uuid[UUID_SIZE], *uuid; char uuid_string[UUID_STRING_LEN + 1]; @@ -1543,14 +1538,14 @@ static int proc_do_uuid(struct ctl_table } snprintf(uuid_string, sizeof(uuid_string), "%pU", uuid); - return proc_dostring(&fake_table, 0, buffer, lenp, ppos); + return proc_dostring(&fake_table, 0, buf, lenp, ppos); } /* The same as proc_dointvec, but writes don't change anything. */ -static int proc_do_rointvec(struct ctl_table *table, int write, void __user *buffer, +static int proc_do_rointvec(struct ctl_table *table, int write, void __user *buf, size_t *lenp, loff_t *ppos) { - return write ? 0 : proc_dointvec(table, 0, buffer, lenp, ppos); + return write ? 0 : proc_dointvec(table, 0, buf, lenp, ppos); } extern struct ctl_table random_table[]; --- a/include/linux/random.h +++ b/include/linux/random.h @@ -12,12 +12,12 @@ struct notifier_block; -void add_device_randomness(const void *, size_t); -void add_bootloader_randomness(const void *, size_t); +void add_device_randomness(const void *buf, size_t len); +void add_bootloader_randomness(const void *buf, size_t len); void add_input_randomness(unsigned int type, unsigned int code, unsigned int value) __latent_entropy; void add_interrupt_randomness(int irq) __latent_entropy; -void add_hwgenerator_randomness(const void *buffer, size_t count, size_t entropy); +void add_hwgenerator_randomness(const void *buf, size_t len, size_t entropy); #if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__) static inline void add_latent_entropy(void) @@ -28,8 +28,8 @@ static inline void add_latent_entropy(vo static inline void add_latent_entropy(void) { } #endif -void get_random_bytes(void *buf, size_t nbytes); -size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes); +void get_random_bytes(void *buf, size_t len); +size_t __must_check get_random_bytes_arch(void *buf, size_t len); u32 get_random_u32(void); u64 get_random_u64(void); static inline unsigned int get_random_int(void) @@ -81,18 +81,18 @@ static inline int get_random_bytes_wait( return ret; } -#define declare_get_random_var_wait(var) \ - static inline int get_random_ ## var ## _wait(var *out) { \ +#define declare_get_random_var_wait(name, ret_type) \ + static inline int get_random_ ## name ## _wait(ret_type *out) { \ int ret = wait_for_random_bytes(); \ if (unlikely(ret)) \ return ret; \ - *out = get_random_ ## var(); \ + *out = get_random_ ## name(); \ return 0; \ } -declare_get_random_var_wait(u32) -declare_get_random_var_wait(u64) -declare_get_random_var_wait(int) -declare_get_random_var_wait(long) +declare_get_random_var_wait(u32, u32) +declare_get_random_var_wait(u64, u32) +declare_get_random_var_wait(int, unsigned int) +declare_get_random_var_wait(long, unsigned long) #undef declare_get_random_var /* Patches currently in stable-queue which might be from Jason@xxxxxxxxx are queue-4.14/random-do-not-take-pool-spinlock-at-boot.patch queue-4.14/random-remove-kernel.random.read_wakeup_threshold.patch queue-4.14/random-simplify-arithmetic-function-flow-in-account.patch queue-4.14/random-order-timer-entropy-functions-below-interrupt-functions.patch queue-4.14/random-introduce-drain_entropy-helper-to-declutter-crng_reseed.patch queue-4.14/random-fix-locking-in-crng_fast_load.patch queue-4.14/random-cleanup-uuid-handling.patch queue-4.14/random-group-userspace-read-write-functions.patch queue-4.14/random-make-credit_entropy_bits-always-safe.patch queue-4.14/latent_entropy-avoid-build-error-when-plugin-cflags-are-not-set.patch queue-4.14/revert-hwrng-core-freeze-khwrng-thread-during-suspend.patch queue-4.14/drivers-char-random.c-make-primary_crng-static.patch queue-4.14/random-do-not-re-init-if-crng_reseed-completes-before-primary-init.patch queue-4.14/random-always-fill-buffer-in-get_random_bytes_wait.patch queue-4.14/random-use-proper-jiffies-comparison-macro.patch queue-4.14/init-call-time_init-before-rand_initialize.patch queue-4.14/random-split-primary-secondary-crng-init-paths.patch queue-4.14/random-pull-add_hwgenerator_randomness-declaration-into-random.h.patch queue-4.14/random-unify-early-init-crng-load-accounting.patch queue-4.14/drivers-char-random.c-remove-unused-stuct-poolinfo-poolbits.patch queue-4.14/random-use-blake2s-instead-of-sha1-in-extraction.patch queue-4.14/random-make-cpu-trust-a-boot-parameter.patch queue-4.14/random-convert-to-using-fops-write_iter.patch queue-4.14/random-initialize-chacha20-constants-with-correct-endianness.patch queue-4.14/random-remove-incomplete-last_data-logic.patch queue-4.14/random-group-entropy-extraction-functions.patch queue-4.14/random-optimize-add_interrupt_randomness.patch queue-4.14/random-add-proper-spdx-header.patch queue-4.14/linux-random.h-remove-arch_has_random-arch_has_random_seed.patch queue-4.14/random-rewrite-header-introductory-comment.patch queue-4.14/random-make-dev-random-be-almost-like-dev-urandom.patch queue-4.14/random-remove-ifdef-d-out-interrupt-bench.patch queue-4.14/um-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/lib-crypto-sha1-re-roll-loops-to-reduce-code-size.patch queue-4.14/random-tie-batched-entropy-generation-to-base_crng-generation.patch queue-4.14/sparc-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/random-use-linear-min-entropy-accumulation-crediting.patch queue-4.14/random-remove-batched-entropy-locking.patch queue-4.14/xtensa-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/powerpc-remove-arch_has_random-arch_has_random_seed.patch queue-4.14/fdt-add-support-for-rng-seed.patch queue-4.14/random-continually-use-hwgenerator-randomness.patch queue-4.14/random-access-input_pool_data-directly-rather-than-through-pointer.patch queue-4.14/random-add-arch_get_random_-long_early.patch queue-4.14/random-inline-leaves-of-rand_initialize.patch queue-4.14/random-cleanup-poolinfo-abstraction.patch queue-4.14/random-wire-up-fops-splice_-read-write-_iter.patch queue-4.14/random-handle-latent-entropy-and-command-line-from-random_init.patch queue-4.14/random-remove-use_input_pool-parameter-from-crng_reseed.patch queue-4.14/random-credit-architectural-init-the-exact-amount.patch queue-4.14/ia64-define-get_cycles-macro-for-arch-override.patch queue-4.14/random-replace-custom-notifier-chain-with-standard-one.patch queue-4.14/random-support-freezable-kthreads-in-add_hwgenerator_randomness.patch queue-4.14/random-document-get_random_int-family.patch queue-4.14/random-remove-the-blocking-pool.patch queue-4.14/random-avoid-initializing-twice-in-credit-race.patch queue-4.14/random-avoid-warnings-for-config_numa-builds.patch queue-4.14/crypto-drbg-add-fips-140-2-ctrng-for-noise-source.patch queue-4.14/random-mark-bootloader-randomness-code-as-__init.patch queue-4.14/random-zero-buffer-after-reading-entropy-from-userspace.patch queue-4.14/random-remove-whitespace-and-reorder-includes.patch queue-4.14/random-ignore-grnd_random-in-getentropy-2.patch queue-4.14/random-clear-fast-pool-crng-and-batches-in-cpuhp-bring-up.patch queue-4.14/random-document-add_hwgenerator_randomness-with-other-input-functions.patch queue-4.14/random-fix-typo-in-add_timer_randomness.patch queue-4.14/random-do-crng-pre-init-loading-in-worker-rather-than-irq.patch queue-4.14/powerpc-use-bool-in-archrandom.h.patch queue-4.14/random-do-not-split-fast-init-input-in-add_hwgenerator_randomness.patch queue-4.14/timekeeping-add-raw-clock-fallback-for-random_get_entropy.patch queue-4.14/random-early-initialization-of-chacha-constants.patch queue-4.14/crypto-drbg-prepare-for-more-fine-grained-tracking-of-seeding-state.patch queue-4.14/random-delete-code-to-pull-data-into-pools.patch queue-4.14/crypto-drbg-always-try-to-free-jitter-rng-instance.patch queue-4.14/random-simplify-entropy-debiting.patch queue-4.14/random-don-t-reset-crng_init_cnt-on-urandom_read.patch queue-4.14/random-skip-fast_init-if-hwrng-provides-large-chunk-of-entropy.patch queue-4.14/random-use-siphash-as-interrupt-entropy-accumulator.patch queue-4.14/random-avoid-checking-crng_ready-twice-in-random_init.patch queue-4.14/random-fix-soft-lockup-when-trying-to-read-from-an-uninitialized-blocking-pool.patch queue-4.14/random-group-sysctl-functions.patch queue-4.14/random-don-t-let-644-read-only-sysctls-be-written-to.patch queue-4.14/random-document-crng_fast_key_erasure-destination-possibility.patch queue-4.14/random-only-wake-up-writers-after-zap-if-threshold-was-passed.patch queue-4.14/random-use-wait_event_freezable-in-add_hwgenerator_randomness.patch queue-4.14/random-check-for-signal-and-try-earlier-when-generating-entropy.patch queue-4.14/random-check-for-signals-every-page_size-chunk-of-dev-random.patch queue-4.14/arm-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/random-absorb-fast-pool-into-input-pool-after-fast-load.patch queue-4.14/random-give-sysctl_random_min_urandom_seed-a-more-sensible-value.patch queue-4.14/crypto-blake2s-generic-c-library-implementation-and-selftest.patch queue-4.14/random-cleanup-fractional-entropy-shift-constants.patch queue-4.14/random-use-rdseed-instead-of-rdrand-in-entropy-extraction.patch queue-4.14/random-move-rand_initialize-earlier.patch queue-4.14/random-don-t-wake-crng_init_wait-when-crng_init-1.patch queue-4.14/random-add-a-urandom_read_nowait-for-random-apis-that-don-t-warn.patch queue-4.14/random-do-not-sign-extend-bytes-for-rotation-when-mixing.patch queue-4.14/random-move-initialization-functions-out-of-hot-pages.patch queue-4.14/random-remove-dead-code-left-over-from-blocking-pool.patch queue-4.14/drivers-char-random.c-constify-poolinfo_table.patch queue-4.14/crypto-drbg-track-whether-drbg-was-seeded-with-rng_is_initialized.patch queue-4.14/random-use-computational-hash-for-entropy-extraction.patch queue-4.14/random-add-and-use-pr_fmt.patch queue-4.14/random-round-robin-registers-as-ulong-not-u32.patch queue-4.14/random-always-wake-up-entropy-writers-after-extraction.patch queue-4.14/s390-remove-arch_has_random-arch_has_random_seed.patch queue-4.14/random-do-not-xor-rdrand-when-writing-into-dev-random.patch queue-4.14/crypto-drbg-make-reseeding-from-get_random_bytes-synchronous.patch queue-4.14/random-convert-to-entropy_bits-for-better-code-readability.patch queue-4.14/char-random-add-a-newline-at-the-end-of-the-file.patch queue-4.14/random-move-randomize_page-into-mm-where-it-belongs.patch queue-4.14/random-only-call-crng_finalize_init-for-primary_crng.patch queue-4.14/random-cleanup-integer-types.patch queue-4.14/random-re-add-removed-comment-about-get_random_-u32-u64-reseeding.patch queue-4.14/random-unify-cycles_t-and-jiffies-usage-and-types.patch queue-4.14/random-insist-on-random_get_entropy-existing-in-order-to-simplify.patch queue-4.14/random-group-initialization-wait-functions.patch queue-4.14/linux-random.h-mark-config_arch_random-functions-__must_check.patch queue-4.14/random-remove-unused-extract_entropy-reserved-argument.patch queue-4.14/random-check-for-signal_pending-outside-of-need_resched-check.patch queue-4.14/random-access-primary_pool-directly-rather-than-through-pointer.patch queue-4.14/random-fix-sysctl-documentation-nits.patch queue-4.14/random-remove-unused-tracepoints.patch queue-4.14/random-only-read-from-dev-random-after-its-pool-has-received-128-bits.patch queue-4.14/nios2-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/random-treat-bootloader-trust-toggle-the-same-way-as-cpu-trust-toggle.patch queue-4.14/random-make-consistent-usage-of-crng_ready.patch queue-4.14/lib-crypto-blake2s-move-hmac-construction-into-wireguard.patch queue-4.14/parisc-define-get_cycles-macro-for-arch-override.patch queue-4.14/x86-tsc-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/crypto-chacha20-fix-keystream-alignment-for-chacha20_block.patch queue-4.14/random-add-grnd_insecure-to-return-best-effort-non-cryptographic-bytes.patch queue-4.14/random-fix-whitespace-pre-random-bytes-work.patch queue-4.14/crypto-drbg-move-dynamic-reseed_threshold-adjustments-to-__drbg_seed.patch queue-4.14/random-check-for-signals-after-page-of-pool-writes.patch queue-4.14/random-make-random_get_entropy-return-an-unsigned-long.patch queue-4.14/random-check-for-crng_init-0-in-add_device_randomness.patch queue-4.14/random-add-a-config-option-to-trust-the-cpu-s-hwrng.patch queue-4.14/random-remove-unnecessary-unlikely.patch queue-4.14/random-defer-fast-pool-mixing-to-worker.patch queue-4.14/random-harmonize-crng-init-done-messages.patch queue-4.14/crypto-blake2s-include-linux-bug.h-instead-of-asm-bug.h.patch queue-4.14/random-use-static-branch-for-crng_ready.patch queue-4.14/random-rather-than-entropy_store-abstraction-use-global.patch queue-4.14/drivers-char-random.c-remove-unused-dont_count_entropy.patch queue-4.14/random-remove-extern-from-functions-in-header.patch queue-4.14/siphash-use-one-source-of-truth-for-siphash-permutations.patch queue-4.14/random-group-entropy-collection-functions.patch queue-4.14/random-de-duplicate-input_pool-constants.patch queue-4.14/random-mix-build-time-latent-entropy-into-pool-at-init.patch queue-4.14/random-remove-useless-header-comment.patch queue-4.14/linux-random.h-use-false-with-bool.patch queue-4.14/maintainers-co-maintain-random.c.patch queue-4.14/random-remove-outdated-int_max-6-check-in-urandom_read.patch queue-4.14/m68k-use-fallback-for-random_get_entropy-instead-of-zero.patch queue-4.14/alpha-define-get_cycles-macro-for-arch-override.patch queue-4.14/random-mix-bootloader-randomness-into-pool.patch queue-4.14/random-remove-some-dead-code-of-poolinfo.patch queue-4.14/random-do-not-use-batches-when-crng_ready.patch queue-4.14/crypto-drbg-always-seeded-with-sp800-90b-compliant-noise-source.patch queue-4.14/s390-define-get_cycles-macro-for-arch-override.patch queue-4.14/random-do-not-pretend-to-handle-premature-next-security-model.patch queue-4.14/random-avoid-arch_get_random_seed_long-when-collecting-irq-randomness.patch queue-4.14/random-use-is_enabled-config_numa-instead-of-ifdefs.patch queue-4.14/random-make-crng-state-queryable.patch queue-4.14/random-avoid-superfluous-call-to-rdrand-in-crng-extraction.patch queue-4.14/random-use-symbolic-constants-for-crng_init-states.patch queue-4.14/random-reseed-more-often-immediately-after-booting.patch queue-4.14/random-ensure-early-rdseed-goes-through-mixer-on-init.patch queue-4.14/random-deobfuscate-irq-u32-u64-contributions.patch queue-4.14/random-do-not-use-input-pool-from-hard-irqs.patch queue-4.14/random-help-compiler-out-with-fast_mix-by-using-simpler-arguments.patch queue-4.14/revert-random-use-static-branch-for-crng_ready.patch queue-4.14/random-fix-crash-on-multiple-early-calls-to-add_bootloader_randomness.patch queue-4.14/random-return-nbytes-filled-from-hw-rng.patch queue-4.14/random-account-for-arch-randomness-in-bits.patch queue-4.14/crypto-blake2s-adjust-include-guard-naming.patch queue-4.14/random-do-not-allow-user-to-keep-crng-key-around-on-stack.patch queue-4.14/x86-remove-arch_has_random-arch_has_random_seed.patch queue-4.14/crypto-deduplicate-le32_to_cpu_array-and-cpu_to_le32_array.patch queue-4.14/random-remove-ratelimiting-for-in-kernel-unseeded-randomness.patch queue-4.14/random-remove-unused-irq_flags-argument-from-add_interrupt_randomness.patch queue-4.14/random-prepend-remaining-pool-constants-with-pool_.patch queue-4.14/powerpc-define-get_cycles-macro-for-arch-override.patch queue-4.14/random-remove-unused-output_pool-constants.patch queue-4.14/mips-use-fallback-for-random_get_entropy-instead-of-just-c0-random.patch queue-4.14/random-use-hash-function-for-crng_slow_load.patch queue-4.14/random-fix-typo-in-comments.patch queue-4.14/random-remove-preempt-disabled-region.patch queue-4.14/random-use-proper-return-types-on-get_random_-int-long-_wait.patch