Line data    Source code

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