random: make consistent use of buf and len

The current code was a mix of "nbytes", "count", "size", "buffer", "in", and so forth. Instead, let's clean this up by naming input parameters "buf" (or "ubuf") and "len", so that you always understand that you're reading this variety of function argument.

Jason A. Donenfeld committed 4 years ago

Commit a1940261 parent 7c3a8a12 files · +103 −108Browse files

Unified · Split

2 files

drivers/char/random.c +97 −102
include/linux/random.h +6 −6

drivers/char/random.c+97−102

  *
  * 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()
 };
 /* 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)
 	local_unlock_irqrestore(&crngs.lock, flags);
 }
-static void _get_random_bytes(void *buf, size_t nbytes)
+static void _get_random_bytes(void *buf, size_t len)
 {
 	u32 chacha_state[CHACHA_STATE_WORDS];
 	u8 tmp[CHACHA_BLOCK_SIZE];
-	size_t len;
+	size_t first_block_len;
-	if (!nbytes)
+	if (!len)
 		return;
-	len = min_t(size_t, 32, nbytes);
+	first_block_len = min_t(size_t, 32, len);
-	crng_make_state(chacha_state, buf, len);
+	crng_make_state(chacha_state, buf, first_block_len);
-	nbytes -= len;
+	len -= first_block_len;
-	buf += len;
+	buf += first_block_len;
-	while (nbytes) {
+	while (len) {
-		if (nbytes < CHACHA_BLOCK_SIZE) {
+		if (len < CHACHA_BLOCK_SIZE) {
 			chacha20_block(chacha_state, tmp);
-			memcpy(buf, tmp, nbytes);
+			memcpy(buf, tmp, len);
 			memzero_explicit(tmp, sizeof(tmp));
 			break;
 		}
 		chacha20_block(chacha_state, buf);
 		if (unlikely(chacha_state[12] == 0))
 			++chacha_state[13];
-		nbytes -= CHACHA_BLOCK_SIZE;
+		len -= CHACHA_BLOCK_SIZE;
 		buf += CHACHA_BLOCK_SIZE;
 	}
  * 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[CHACHA_STATE_WORDS];
 	u8 output[CHACHA_BLOCK_SIZE];
-	if (!nbytes)
+	if (!len)
 		return 0;
 	/*
 	 * use chacha_state after, so we can simply return those bytes to
 	 * the user directly.
 	 */
-	if (nbytes <= CHACHA_KEY_SIZE) {
+	if (len <= CHACHA_KEY_SIZE) {
-		ret = nbytes - copy_to_user(buf, &chacha_state[4], nbytes);
+		ret = len - copy_to_user(ubuf, &chacha_state[4], len);
 		goto out_zero_chacha;
 	}
 		if (unlikely(chacha_state[12] == 0))
 			++chacha_state[13];
-		len = min_t(size_t, nbytes, CHACHA_BLOCK_SIZE);
+		block_len = min_t(size_t, len, CHACHA_BLOCK_SIZE);
-		left = copy_to_user(buf, output, len);
+		left = copy_to_user(ubuf, output, block_len);
 		if (left) {
-			ret += len - left;
+			ret += block_len - left;
 			break;
 		}
-		buf += len;
+		ubuf += block_len;
-		ret += len;
+		ret += block_len;
-		nbytes -= len;
+		len -= block_len;
-		if (!nbytes)
+		if (!len)
 			break;
 		BUILD_BUG_ON(PAGE_SIZE % CHACHA_BLOCK_SIZE != 0);
  * 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);
+		memcpy(p, &v, block_len);
-		p += chunk;
+		p += block_len;
-		left -= chunk;
+		left -= block_len;
 	}
-	return nbytes - left;
+	return len - left;
 }
 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)
  *
  **********************************************************************/
 	.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);
 }
 /*
  * 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);
 }
  * 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];
 	spin_unlock_irqrestore(&input_pool.lock, flags);
 	memzero_explicit(next_key, sizeof(next_key));
-	while (nbytes) {
+	while (len) {
-		i = min_t(size_t, nbytes, BLAKE2S_HASH_SIZE);
+		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;
 	}
 	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);
  * 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_device_randomness(const void *buf, size_t len);
- *	void add_hwgenerator_randomness(const void *buffer, size_t count,
+ *	void add_hwgenerator_randomness(const void *buf, size_t len, size_t entropy);
- *					size_t entropy);
+ *	void add_bootloader_randomness(const void *buf, size_t len);
- *	void add_bootloader_randomness(const void *buf, size_t size);
+ *	void add_vmfork_randomness(const void *unique_vm_id, size_t len);
- *	void add_vmfork_randomness(const void *unique_vm_id, size_t size);
  *	void add_interrupt_randomness(int irq);
- *	void add_input_randomness(unsigned int type, unsigned int code,
+ *	void add_input_randomness(unsigned int type, unsigned int code, unsigned int value);
- *	                          unsigned int value);
  *	void add_disk_randomness(struct gendisk *disk);
  *
  * add_device_randomness() adds data to the input pool that
 {
 	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;
 #endif
 	for (i = 0, arch_bytes = BLAKE2S_BLOCK_SIZE;
-	     i < BLAKE2S_BLOCK_SIZE; i += sizeof(rv)) {
+	     i < BLAKE2S_BLOCK_SIZE; i += sizeof(entropy)) {
-		if (!arch_get_random_seed_long_early(&rv) &&
+		if (!arch_get_random_seed_long_early(&entropy) &&
-		    !arch_get_random_long_early(&rv)) {
+		    !arch_get_random_long_early(&entropy)) {
-			rv = random_get_entropy();
+			entropy = random_get_entropy();
-			arch_bytes -= sizeof(rv);
+			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())));
  * 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);
  * 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,
+void add_hwgenerator_randomness(const void *buf, size_t len, size_t entropy)
-				size_t entropy)
 {
-	mix_pool_bytes(buffer, count);
+	mix_pool_bytes(buf, len);
 	credit_init_bits(entropy);
 	/*
  * 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);
  * don't credit it, but we do immediately force a reseed after so
  * that it's used by the crng posthaste.
  */
-void add_vmfork_randomness(const void *unique_vm_id, size_t size)
+void add_vmfork_randomness(const void *unique_vm_id, size_t len)
 {
-	add_device_randomness(unique_vm_id, size);
+	add_device_randomness(unique_vm_id, len);
 	if (crng_ready()) {
 		crng_reseed();
 		pr_notice("crng reseeded due to virtual machine fork\n");
 		credit_init_bits(bits);
 }
-void add_input_randomness(unsigned int type, unsigned int code,
+void add_input_randomness(unsigned int type, unsigned int code, unsigned int value)
-			  unsigned int value)
 {
 	static unsigned char last_value;
 	static struct timer_rand_state input_timer_state = { INITIAL_JIFFIES };
  *
  **********************************************************************/
-SYSCALL_DEFINE3(getrandom, char __user *, buf, size_t, count, unsigned int,
+SYSCALL_DEFINE3(getrandom, char __user *, ubuf, size_t, len, unsigned int, flags)
-		flags)
 {
 	if (flags & ~(GRND_NONBLOCK | GRND_RANDOM | GRND_INSECURE))
 		return -EINVAL;
 	if ((flags & (GRND_INSECURE | GRND_RANDOM)) == (GRND_INSECURE | GRND_RANDOM))
 		return -EINVAL;
-	if (count > INT_MAX)
+	if (len > INT_MAX)
-		count = INT_MAX;
+		len = INT_MAX;
 	if (!crng_ready() && !(flags & GRND_INSECURE)) {
 		int ret;
 		if (unlikely(ret))
 			return ret;
 	}
-	return get_random_bytes_user(buf, count);
+	return get_random_bytes_user(ubuf, len);
 }
 static __poll_t random_poll(struct file *file, poll_table *wait)
 	return crng_ready() ? EPOLLIN | EPOLLRDNORM : EPOLLOUT | EPOLLWRNORM;
 }
-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) {
+	while (len) {
-		len = min(count, sizeof(block));
+		block_len = min(len, sizeof(block));
-		if (copy_from_user(block, ubuf, len)) {
+		if (copy_from_user(block, ubuf, block_len)) {
 			ret = -EFAULT;
 			goto out;
 		}
-		count -= len;
+		len -= block_len;
-		ubuf += len;
+		ubuf += block_len;
-		mix_pool_bytes(block, len);
+		mix_pool_bytes(block, block_len);
 		cond_resched();
 	}
 	return ret;
 }
-static ssize_t random_write(struct file *file, const char __user *buffer,
+static ssize_t random_write(struct file *file, const char __user *ubuf,
-			    size_t count, loff_t *ppos)
+			    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,
+static ssize_t urandom_read(struct file *file, char __user *ubuf,
-			    loff_t *ppos)
+			    size_t len, loff_t *ppos)
 {
 	static int maxwarn = 10;
 		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,
+static ssize_t random_read(struct file *file, char __user *ubuf,
-			   loff_t *ppos)
+			   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)
  * 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 *buffer,
+static int proc_do_uuid(struct ctl_table *table, int write, void *buf,
 			size_t *lenp, loff_t *ppos)
 {
 	u8 tmp_uuid[UUID_SIZE], *uuid;
 	}
 	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 *buffer,
+static int proc_do_rointvec(struct ctl_table *table, int write, void *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);
 }
 static struct ctl_table random_table[] = {

include/linux/random.h+6−6

@@ -12,12 +12,12 @@ · 11 unmodified lines
12		12
13	struct notifier_block;	13	struct notifier_block;
14		14
15	void add_device_randomness(const void *, size_t);	15	void add_device_randomness(const void *buf, size_t len);
16	void add_bootloader_randomness(const void *, size_t);	16	void add_bootloader_randomness(const void *buf, size_t len);
17	void add_input_randomness(unsigned int type, unsigned int code,	17	void add_input_randomness(unsigned int type, unsigned int code,
18	unsigned int value) __latent_entropy;	18	unsigned int value) __latent_entropy;
19	void add_interrupt_randomness(int irq) __latent_entropy;	19	void add_interrupt_randomness(int irq) __latent_entropy;
20	void add_hwgenerator_randomness(const void *buffer, size_t count, size_t entropy);	20	void add_hwgenerator_randomness(const void *buf, size_t len, size_t entropy);
21		21
22	#if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__)	22	#if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__)
23	static inline void add_latent_entropy(void)	23	static inline void add_latent_entropy(void)
@@ -29,7 +29,7 @@ static inline void add_latent_entropy(void) { } · 5 unmodified lines
29	#endif	29	#endif
30		30
31	#if IS_ENABLED(CONFIG_VMGENID)	31	#if IS_ENABLED(CONFIG_VMGENID)
32	void add_vmfork_randomness(const void *unique_vm_id, size_t size);	32	void add_vmfork_randomness(const void *unique_vm_id, size_t len);
33	int register_random_vmfork_notifier(struct notifier_block *nb);	33	int register_random_vmfork_notifier(struct notifier_block *nb);
34	int unregister_random_vmfork_notifier(struct notifier_block *nb);	34	int unregister_random_vmfork_notifier(struct notifier_block *nb);
35	#else	35	#else
@@ -37,8 +37,8 @@ static inline int register_random_vmfork_notifier(struct notifier_block *nb) { r · 1 unmodified line
37	static inline int unregister_random_vmfork_notifier(struct notifier_block *nb) { return 0; }	37	static inline int unregister_random_vmfork_notifier(struct notifier_block *nb) { return 0; }
38	#endif	38	#endif
39		39
40	void get_random_bytes(void *buf, size_t nbytes);	40	void get_random_bytes(void *buf, size_t len);
41	size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes);	41	size_t __must_check get_random_bytes_arch(void *buf, size_t len);
42	u32 get_random_u32(void);	42	u32 get_random_u32(void);
43	u64 get_random_u64(void);	43	u64 get_random_u64(void);
44	static inline unsigned int get_random_int(void)	44	static inline unsigned int get_random_int(void)