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 13 struct notifier_block; 14 15 extern void add_device_randomness(const void *, size_t); 16 extern void add_bootloader_randomness(const void *, size_t); 17 18 #if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__) 19 static inline void add_latent_entropy(void) 20 { 21 add_device_randomness((const void *)&latent_entropy, 22 sizeof(latent_entropy)); 23 } 24 #else 25 static inline void add_latent_entropy(void) {} 26 #endif 27 28 extern void add_input_randomness(unsigned int type, unsigned int code, 29 unsigned int value) __latent_entropy; 30 extern void add_interrupt_randomness(int irq) __latent_entropy; 31 extern void add_hwgenerator_randomness(const void *buffer, size_t count, 32 size_t entropy); 33 #if IS_ENABLED(CONFIG_VMGENID) 34 extern void add_vmfork_randomness(const void *unique_vm_id, size_t size); 35 extern int register_random_vmfork_notifier(struct notifier_block *nb); 36 extern int unregister_random_vmfork_notifier(struct notifier_block *nb); 37 #else 38 static inline int register_random_vmfork_notifier(struct notifier_block *nb) { return 0; } 39 static inline int unregister_random_vmfork_notifier(struct notifier_block *nb) { return 0; } 40 #endif 41 42 extern void get_random_bytes(void *buf, size_t nbytes); 43 extern int wait_for_random_bytes(void); 44 extern int __init rand_initialize(void); 45 extern bool rng_is_initialized(void); 46 extern int register_random_ready_notifier(struct notifier_block *nb); 47 extern int unregister_random_ready_notifier(struct notifier_block *nb); 48 extern size_t __must_check get_random_bytes_arch(void *buf, size_t nbytes); 49 50 #ifndef MODULE 51 extern const struct file_operations random_fops, urandom_fops; 52 #endif 53 54 u32 get_random_u32(void); 55 u64 get_random_u64(void); 56 static inline unsigned int get_random_int(void) 57 { 58 return get_random_u32(); 59 } 60 static 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 83 static 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. */ 92 static 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 } 107 declare_get_random_var_wait(u32) 108 declare_get_random_var_wait(u64) 109 declare_get_random_var_wait(int) 110 declare_get_random_var_wait(long) 111 #undef declare_get_random_var 112 113 unsigned 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 125 static inline bool __must_check arch_get_random_long(unsigned long *v) 126 { 127 return false; 128 } 129 static inline bool __must_check arch_get_random_int(unsigned int *v) 130 { 131 return false; 132 } 133 static inline bool __must_check arch_get_random_seed_long(unsigned long *v) 134 { 135 return false; 136 } 137 static 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 148 static 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 156 static 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 164 extern int random_prepare_cpu(unsigned int cpu); 165 extern int random_online_cpu(unsigned int cpu); 166 #endif 167 168 #endif /* _LINUX_RANDOM_H */ 169