1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * include/linux/random.h |
4 | * |
5 | * Include file for the random number generator. |
6 | */ |
7 | #ifndef _LINUX_RANDOM_H |
8 | #define _LINUX_RANDOM_H |
9 | |
10 | #include <linux/list.h> |
11 | #include <linux/once.h> |
12 | |
13 | #include <uapi/linux/random.h> |
14 | |
15 | struct random_ready_callback { |
16 | struct list_head list; |
17 | void (*func)(struct random_ready_callback *rdy); |
18 | struct module *owner; |
19 | }; |
20 | |
21 | extern void add_device_randomness(const void *, unsigned int); |
22 | |
23 | #if defined(CONFIG_GCC_PLUGIN_LATENT_ENTROPY) && !defined(__CHECKER__) |
24 | static inline void add_latent_entropy(void) |
25 | { |
26 | add_device_randomness((const void *)&latent_entropy, |
27 | sizeof(latent_entropy)); |
28 | } |
29 | #else |
30 | static inline void add_latent_entropy(void) {} |
31 | #endif |
32 | |
33 | extern void add_input_randomness(unsigned int type, unsigned int code, |
34 | unsigned int value) __latent_entropy; |
35 | extern void add_interrupt_randomness(int irq, int irq_flags) __latent_entropy; |
36 | |
37 | extern void get_random_bytes(void *buf, int nbytes); |
38 | extern int wait_for_random_bytes(void); |
39 | extern bool rng_is_initialized(void); |
40 | extern int add_random_ready_callback(struct random_ready_callback *rdy); |
41 | extern void del_random_ready_callback(struct random_ready_callback *rdy); |
42 | extern int __must_check get_random_bytes_arch(void *buf, int nbytes); |
43 | |
44 | #ifndef MODULE |
45 | extern const struct file_operations random_fops, urandom_fops; |
46 | #endif |
47 | |
48 | u32 get_random_u32(void); |
49 | u64 get_random_u64(void); |
50 | static inline unsigned int get_random_int(void) |
51 | { |
52 | return get_random_u32(); |
53 | } |
54 | static inline unsigned long get_random_long(void) |
55 | { |
56 | #if BITS_PER_LONG == 64 |
57 | return get_random_u64(); |
58 | #else |
59 | return get_random_u32(); |
60 | #endif |
61 | } |
62 | |
63 | /* |
64 | * On 64-bit architectures, protect against non-terminated C string overflows |
65 | * by zeroing out the first byte of the canary; this leaves 56 bits of entropy. |
66 | */ |
67 | #ifdef CONFIG_64BIT |
68 | # ifdef __LITTLE_ENDIAN |
69 | # define CANARY_MASK 0xffffffffffffff00UL |
70 | # else /* big endian, 64 bits: */ |
71 | # define CANARY_MASK 0x00ffffffffffffffUL |
72 | # endif |
73 | #else /* 32 bits: */ |
74 | # define CANARY_MASK 0xffffffffUL |
75 | #endif |
76 | |
77 | static inline unsigned long get_random_canary(void) |
78 | { |
79 | unsigned long val = get_random_long(); |
80 | |
81 | return val & CANARY_MASK; |
82 | } |
83 | |
84 | /* Calls wait_for_random_bytes() and then calls get_random_bytes(buf, nbytes). |
85 | * Returns the result of the call to wait_for_random_bytes. */ |
86 | static inline int get_random_bytes_wait(void *buf, int nbytes) |
87 | { |
88 | int ret = wait_for_random_bytes(); |
89 | get_random_bytes(buf, nbytes); |
90 | return ret; |
91 | } |
92 | |
93 | #define declare_get_random_var_wait(var) \ |
94 | static inline int get_random_ ## var ## _wait(var *out) { \ |
95 | int ret = wait_for_random_bytes(); \ |
96 | if (unlikely(ret)) \ |
97 | return ret; \ |
98 | *out = get_random_ ## var(); \ |
99 | return 0; \ |
100 | } |
101 | declare_get_random_var_wait(u32) |
102 | declare_get_random_var_wait(u64) |
103 | declare_get_random_var_wait(int) |
104 | declare_get_random_var_wait(long) |
105 | #undef declare_get_random_var |
106 | |
107 | unsigned long randomize_page(unsigned long start, unsigned long range); |
108 | |
109 | u32 prandom_u32(void); |
110 | void prandom_bytes(void *buf, size_t nbytes); |
111 | void prandom_seed(u32 seed); |
112 | void prandom_reseed_late(void); |
113 | |
114 | struct rnd_state { |
115 | __u32 s1, s2, s3, s4; |
116 | }; |
117 | |
118 | u32 prandom_u32_state(struct rnd_state *state); |
119 | void prandom_bytes_state(struct rnd_state *state, void *buf, size_t nbytes); |
120 | void prandom_seed_full_state(struct rnd_state __percpu *pcpu_state); |
121 | |
122 | #define prandom_init_once(pcpu_state) \ |
123 | DO_ONCE(prandom_seed_full_state, (pcpu_state)) |
124 | |
125 | /** |
126 | * prandom_u32_max - returns a pseudo-random number in interval [0, ep_ro) |
127 | * @ep_ro: right open interval endpoint |
128 | * |
129 | * Returns a pseudo-random number that is in interval [0, ep_ro). Note |
130 | * that the result depends on PRNG being well distributed in [0, ~0U] |
131 | * u32 space. Here we use maximally equidistributed combined Tausworthe |
132 | * generator, that is, prandom_u32(). This is useful when requesting a |
133 | * random index of an array containing ep_ro elements, for example. |
134 | * |
135 | * Returns: pseudo-random number in interval [0, ep_ro) |
136 | */ |
137 | static inline u32 prandom_u32_max(u32 ep_ro) |
138 | { |
139 | return (u32)(((u64) prandom_u32() * ep_ro) >> 32); |
140 | } |
141 | |
142 | /* |
143 | * Handle minimum values for seeds |
144 | */ |
145 | static inline u32 __seed(u32 x, u32 m) |
146 | { |
147 | return (x < m) ? x + m : x; |
148 | } |
149 | |
150 | /** |
151 | * prandom_seed_state - set seed for prandom_u32_state(). |
152 | * @state: pointer to state structure to receive the seed. |
153 | * @seed: arbitrary 64-bit value to use as a seed. |
154 | */ |
155 | static inline void prandom_seed_state(struct rnd_state *state, u64 seed) |
156 | { |
157 | u32 i = (seed >> 32) ^ (seed << 10) ^ seed; |
158 | |
159 | state->s1 = __seed(i, 2U); |
160 | state->s2 = __seed(i, 8U); |
161 | state->s3 = __seed(i, 16U); |
162 | state->s4 = __seed(i, 128U); |
163 | } |
164 | |
165 | #ifdef CONFIG_ARCH_RANDOM |
166 | # include <asm/archrandom.h> |
167 | #else |
168 | static inline bool arch_get_random_long(unsigned long *v) |
169 | { |
170 | return 0; |
171 | } |
172 | static inline bool arch_get_random_int(unsigned int *v) |
173 | { |
174 | return 0; |
175 | } |
176 | static inline bool arch_has_random(void) |
177 | { |
178 | return 0; |
179 | } |
180 | static inline bool arch_get_random_seed_long(unsigned long *v) |
181 | { |
182 | return 0; |
183 | } |
184 | static inline bool arch_get_random_seed_int(unsigned int *v) |
185 | { |
186 | return 0; |
187 | } |
188 | static inline bool arch_has_random_seed(void) |
189 | { |
190 | return 0; |
191 | } |
192 | #endif |
193 | |
194 | /* Pseudo random number generator from numerical recipes. */ |
195 | static inline u32 next_pseudo_random32(u32 seed) |
196 | { |
197 | return seed * 1664525 + 1013904223; |
198 | } |
199 | |
200 | #endif /* _LINUX_RANDOM_H */ |
201 | |