Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/* SPDX-License-Identifier: GPL-2.0 */
2
3#ifndef _LINUX_RANDOM_H
4#define _LINUX_RANDOM_H
5
6#include <linux/bug.h>
7#include <linux/kernel.h>
8#include <linux/list.h>
9#include <linux/once.h>
10
11#include <uapi/linux/random.h>
12
13struct notifier_block;
14
15extern void add_device_randomness(const void *, size_t);
16extern void add_bootloader_randomness(const void *, size_t);
17
18#if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__)
19static inline void add_latent_entropy(void)
20{
21 add_device_randomness((const void *)&latent_entropy,
22 sizeof(latent_entropy));
23}
24#else
25static inline void add_latent_entropy(void) {}
26#endif
27
28extern void add_input_randomness(unsigned int type, unsigned int code,
29 unsigned int value) __latent_entropy;
30extern void add_interrupt_randomness(int irq) __latent_entropy;
31extern void add_hwgenerator_randomness(const void *buffer, size_t count,
32 size_t entropy);
33#if IS_ENABLED(CONFIG_VMGENID)
34extern void add_vmfork_randomness(const void *unique_vm_id, size_t size);
35extern int register_random_vmfork_notifier(struct notifier_block *nb);
36extern int unregister_random_vmfork_notifier(struct notifier_block *nb);
37#else
38static inline int register_random_vmfork_notifier(struct notifier_block *nb) { return 0; }
39static inline int unregister_random_vmfork_notifier(struct notifier_block *nb) { return 0; }
40#endif
41
42extern void get_random_bytes(void *buf, size_t nbytes);
43extern int wait_for_random_bytes(void);
44extern int __init rand_initialize(void);
45extern bool rng_is_initialized(void);
46extern int register_random_ready_notifier(struct notifier_block *nb);
47extern int unregister_random_ready_notifier(struct notifier_block *nb);
48extern size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes);
49
50#ifndef MODULE
51extern const struct file_operations random_fops, urandom_fops;
52#endif
53
54u32 get_random_u32(void);
55u64 get_random_u64(void);
56static inline unsigned int get_random_int(void)
57{
58 return get_random_u32();
59}
60static inline unsigned long get_random_long(void)
61{
62#if BITS_PER_LONG == 64
63 return get_random_u64();
64#else
65 return get_random_u32();
66#endif
67}
68
69/*
70 * On 64-bit architectures, protect against non-terminated C string overflows
71 * by zeroing out the first byte of the canary; this leaves 56 bits of entropy.
72 */
73#ifdef CONFIG_64BIT
74# ifdef __LITTLE_ENDIAN
75# define CANARY_MASK 0xffffffffffffff00UL
76# else /* big endian, 64 bits: */
77# define CANARY_MASK 0x00ffffffffffffffUL
78# endif
79#else /* 32 bits: */
80# define CANARY_MASK 0xffffffffUL
81#endif
82
83static inline unsigned long get_random_canary(void)
84{
85 unsigned long val = get_random_long();
86
87 return val & CANARY_MASK;
88}
89
90/* Calls wait_for_random_bytes() and then calls get_random_bytes(buf, nbytes).
91 * Returns the result of the call to wait_for_random_bytes. */
92static inline int get_random_bytes_wait(void *buf, size_t nbytes)
93{
94 int ret = wait_for_random_bytes();
95 get_random_bytes(buf, nbytes);
96 return ret;
97}
98
99#define declare_get_random_var_wait(var) \
100 static inline int get_random_ ## var ## _wait(var *out) { \
101 int ret = wait_for_random_bytes(); \
102 if (unlikely(ret)) \
103 return ret; \
104 *out = get_random_ ## var(); \
105 return 0; \
106 }
107declare_get_random_var_wait(u32)
108declare_get_random_var_wait(u64)
109declare_get_random_var_wait(int)
110declare_get_random_var_wait(long)
111#undef declare_get_random_var
112
113unsigned long randomize_page(unsigned long start, unsigned long range);
114
115/*
116 * This is designed to be standalone for just prandom
117 * users, but for now we include it from <linux/random.h>
118 * for legacy reasons.
119 */
120#include <linux/prandom.h>
121
122#ifdef CONFIG_ARCH_RANDOM
123# include <asm/archrandom.h>
124#else
125static inline bool __must_check arch_get_random_long(unsigned long *v)
126{
127 return false;
128}
129static inline bool __must_check arch_get_random_int(unsigned int *v)
130{
131 return false;
132}
133static inline bool __must_check arch_get_random_seed_long(unsigned long *v)
134{
135 return false;
136}
137static inline bool __must_check arch_get_random_seed_int(unsigned int *v)
138{
139 return false;
140}
141#endif
142
143/*
144 * Called from the boot CPU during startup; not valid to call once
145 * secondary CPUs are up and preemption is possible.
146 */
147#ifndef arch_get_random_seed_long_early
148static inline bool __init arch_get_random_seed_long_early(unsigned long *v)
149{
150 WARN_ON(system_state != SYSTEM_BOOTING);
151 return arch_get_random_seed_long(v);
152}
153#endif
154
155#ifndef arch_get_random_long_early
156static inline bool __init arch_get_random_long_early(unsigned long *v)
157{
158 WARN_ON(system_state != SYSTEM_BOOTING);
159 return arch_get_random_long(v);
160}
161#endif
162
163#ifdef CONFIG_SMP
164extern int random_prepare_cpu(unsigned int cpu);
165extern int random_online_cpu(unsigned int cpu);
166#endif
167
168#endif /* _LINUX_RANDOM_H */