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

Commit 1ac040b1 authored by Jason A. Donenfeld's avatar Jason A. Donenfeld Committed by Olav Haugan
Browse files

random: convert get_random_int/long into get_random_u32/u64 



Many times, when a user wants a random number, he wants a random number
of a guaranteed size. So, thinking of get_random_int and get_random_long
in terms of get_random_u32 and get_random_u64 makes it much easier to
achieve this. It also makes the code simpler.

On 32-bit platforms, get_random_int and get_random_long are both aliased
to get_random_u32. On 64-bit platforms, int->u32 and long->u64.

Change-Id: Ifd5a3a6be1ef44cb8f312b7545b4835c4f82089d
Signed-off-by: default avatarJason A. Donenfeld <Jason@zx2c4.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Theodore Ts'o <tytso@mit.edu>
Signed-off-by: default avatarTheodore Ts'o <tytso@mit.edu>
Git-commit: c440408cf6901eeb2c09563397e24a9097907078
Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git


Signed-off-by: default avatarOlav Haugan <ohaugan@codeaurora.org>
parent 5218d13b

drivers/char/random.c

+27 −28
Original line number Diff line number Diff line
@@ -2044,8 +2044,8 @@ struct ctl_table random_table[] = { 


struct batched_entropy {

	union {

		unsigned long entropy_long[CHACHA20_BLOCK_SIZE / sizeof(unsigned long)];

		unsigned int entropy_int[CHACHA20_BLOCK_SIZE / sizeof(unsigned int)];

		u64 entropy_u64[CHACHA20_BLOCK_SIZE / sizeof(u64)];

		u32 entropy_u32[CHACHA20_BLOCK_SIZE / sizeof(u32)];

	};

	unsigned int position;

};
@@ -2055,52 +2055,51 @@ struct batched_entropy { 
 * number is either as good as RDRAND or as good as /dev/urandom, with the

 * goal of being quite fast and not depleting entropy.

 */

static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_long);

unsigned long get_random_long(void)

static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u64);

u64 get_random_u64(void)

{

	unsigned long ret;

	u64 ret;

	struct batched_entropy *batch;



	if (arch_get_random_long(&ret))

#if BITS_PER_LONG == 64

	if (arch_get_random_long((unsigned long *)&ret))

		return ret;

#else

	if (arch_get_random_long((unsigned long *)&ret) &&

	    arch_get_random_long((unsigned long *)&ret + 1))

	    return ret;

#endif



	batch = &get_cpu_var(batched_entropy_long);

	if (batch->position % ARRAY_SIZE(batch->entropy_long) == 0) {

		extract_crng((u8 *)batch->entropy_long);

	batch = &get_cpu_var(batched_entropy_u64);

	if (batch->position % ARRAY_SIZE(batch->entropy_u64) == 0) {

		extract_crng((u8 *)batch->entropy_u64);

		batch->position = 0;

	}

	ret = batch->entropy_long[batch->position++];

	put_cpu_var(batched_entropy_long);

	ret = batch->entropy_u64[batch->position++];

	put_cpu_var(batched_entropy_u64);

	return ret;

}

EXPORT_SYMBOL(get_random_long);

EXPORT_SYMBOL(get_random_u64);



#if BITS_PER_LONG == 32

unsigned int get_random_int(void)

static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_u32);

u32 get_random_u32(void)

{

	return get_random_long();

}

#else

static DEFINE_PER_CPU(struct batched_entropy, batched_entropy_int);

unsigned int get_random_int(void)

{

	unsigned int ret;

	u32 ret;

	struct batched_entropy *batch;



	if (arch_get_random_int(&ret))

		return ret;



	batch = &get_cpu_var(batched_entropy_int);

	if (batch->position % ARRAY_SIZE(batch->entropy_int) == 0) {

		extract_crng((u8 *)batch->entropy_int);

	batch = &get_cpu_var(batched_entropy_u32);

	if (batch->position % ARRAY_SIZE(batch->entropy_u32) == 0) {

		extract_crng((u8 *)batch->entropy_u32);

		batch->position = 0;

	}

	ret = batch->entropy_int[batch->position++];

	put_cpu_var(batched_entropy_int);

	ret = batch->entropy_u32[batch->position++];

	put_cpu_var(batched_entropy_u32);

	return ret;

}

#endif

EXPORT_SYMBOL(get_random_int);

EXPORT_SYMBOL(get_random_u32);



/**

 * randomize_page - Generate a random, page aligned address

include/linux/random.h

+15 −2
Original line number Diff line number Diff line
@@ -42,8 +42,21 @@ extern void get_random_bytes_arch(void *buf, int nbytes); 
extern const struct file_operations random_fops, urandom_fops;

#endif



unsigned int get_random_int(void);

unsigned long get_random_long(void);

u32 get_random_u32(void);

u64 get_random_u64(void);

static inline unsigned int get_random_int(void)

{

	return get_random_u32();

}

static inline unsigned long get_random_long(void)

{

#if BITS_PER_LONG == 64

	return get_random_u64();

#else

	return get_random_u32();

#endif

}



unsigned long randomize_page(unsigned long start, unsigned long range);



u32 prandom_u32(void);