LCOV - code coverage report
Current view: top level - lib - random32.c (source / functions) Hit Total Coverage
Test: Real Lines: 85 93 91.4 %
Date: 2020-10-17 15:46:16 Functions: 0 14 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * This is a maximally equidistributed combined Tausworthe generator
       4                 :            :  * based on code from GNU Scientific Library 1.5 (30 Jun 2004)
       5                 :            :  *
       6                 :            :  * lfsr113 version:
       7                 :            :  *
       8                 :            :  * x_n = (s1_n ^ s2_n ^ s3_n ^ s4_n)
       9                 :            :  *
      10                 :            :  * s1_{n+1} = (((s1_n & 4294967294) << 18) ^ (((s1_n <<  6) ^ s1_n) >> 13))
      11                 :            :  * s2_{n+1} = (((s2_n & 4294967288) <<  2) ^ (((s2_n <<  2) ^ s2_n) >> 27))
      12                 :            :  * s3_{n+1} = (((s3_n & 4294967280) <<  7) ^ (((s3_n << 13) ^ s3_n) >> 21))
      13                 :            :  * s4_{n+1} = (((s4_n & 4294967168) << 13) ^ (((s4_n <<  3) ^ s4_n) >> 12))
      14                 :            :  *
      15                 :            :  * The period of this generator is about 2^113 (see erratum paper).
      16                 :            :  *
      17                 :            :  * From: P. L'Ecuyer, "Maximally Equidistributed Combined Tausworthe
      18                 :            :  * Generators", Mathematics of Computation, 65, 213 (1996), 203--213:
      19                 :            :  * http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme.ps
      20                 :            :  * ftp://ftp.iro.umontreal.ca/pub/simulation/lecuyer/papers/tausme.ps
      21                 :            :  *
      22                 :            :  * There is an erratum in the paper "Tables of Maximally Equidistributed
      23                 :            :  * Combined LFSR Generators", Mathematics of Computation, 68, 225 (1999),
      24                 :            :  * 261--269: http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme2.ps
      25                 :            :  *
      26                 :            :  *      ... the k_j most significant bits of z_j must be non-zero,
      27                 :            :  *      for each j. (Note: this restriction also applies to the
      28                 :            :  *      computer code given in [4], but was mistakenly not mentioned
      29                 :            :  *      in that paper.)
      30                 :            :  *
      31                 :            :  * This affects the seeding procedure by imposing the requirement
      32                 :            :  * s1 > 1, s2 > 7, s3 > 15, s4 > 127.
      33                 :            :  */
      34                 :            : 
      35                 :            : #include <linux/types.h>
      36                 :            : #include <linux/percpu.h>
      37                 :            : #include <linux/export.h>
      38                 :            : #include <linux/jiffies.h>
      39                 :            : #include <linux/random.h>
      40                 :            : #include <linux/sched.h>
      41                 :            : #include <asm/unaligned.h>
      42                 :            : 
      43                 :            : #ifdef CONFIG_RANDOM32_SELFTEST
      44                 :            : static void __init prandom_state_selftest(void);
      45                 :            : #else
      46                 :            : static inline void prandom_state_selftest(void)
      47                 :            : {
      48                 :            : }
      49                 :            : #endif
      50                 :            : 
      51                 :            : DEFINE_PER_CPU(struct rnd_state, net_rand_state);
      52                 :            : 
      53                 :            : /**
      54                 :            :  *      prandom_u32_state - seeded pseudo-random number generator.
      55                 :            :  *      @state: pointer to state structure holding seeded state.
      56                 :            :  *
      57                 :            :  *      This is used for pseudo-randomness with no outside seeding.
      58                 :            :  *      For more random results, use prandom_u32().
      59                 :            :  */
      60                 :          3 : u32 prandom_u32_state(struct rnd_state *state)
      61                 :            : {
      62                 :            : #define TAUSWORTHE(s, a, b, c, d) ((s & c) << d) ^ (((s << a) ^ s) >> b)
      63                 :          3 :         state->s1 = TAUSWORTHE(state->s1,  6U, 13U, 4294967294U, 18U);
      64                 :          3 :         state->s2 = TAUSWORTHE(state->s2,  2U, 27U, 4294967288U,  2U);
      65                 :          3 :         state->s3 = TAUSWORTHE(state->s3, 13U, 21U, 4294967280U,  7U);
      66                 :          3 :         state->s4 = TAUSWORTHE(state->s4,  3U, 12U, 4294967168U, 13U);
      67                 :            : 
      68                 :          3 :         return (state->s1 ^ state->s2 ^ state->s3 ^ state->s4);
      69                 :            : }
      70                 :            : EXPORT_SYMBOL(prandom_u32_state);
      71                 :            : 
      72                 :            : /**
      73                 :            :  *      prandom_u32 - pseudo random number generator
      74                 :            :  *
      75                 :            :  *      A 32 bit pseudo-random number is generated using a fast
      76                 :            :  *      algorithm suitable for simulation. This algorithm is NOT
      77                 :            :  *      considered safe for cryptographic use.
      78                 :            :  */
      79                 :          3 : u32 prandom_u32(void)
      80                 :            : {
      81                 :          3 :         struct rnd_state *state = &get_cpu_var(net_rand_state);
      82                 :            :         u32 res;
      83                 :            : 
      84                 :          3 :         res = prandom_u32_state(state);
      85                 :          3 :         put_cpu_var(net_rand_state);
      86                 :            : 
      87                 :          3 :         return res;
      88                 :            : }
      89                 :            : EXPORT_SYMBOL(prandom_u32);
      90                 :            : 
      91                 :            : /**
      92                 :            :  *      prandom_bytes_state - get the requested number of pseudo-random bytes
      93                 :            :  *
      94                 :            :  *      @state: pointer to state structure holding seeded state.
      95                 :            :  *      @buf: where to copy the pseudo-random bytes to
      96                 :            :  *      @bytes: the requested number of bytes
      97                 :            :  *
      98                 :            :  *      This is used for pseudo-randomness with no outside seeding.
      99                 :            :  *      For more random results, use prandom_bytes().
     100                 :            :  */
     101                 :          3 : void prandom_bytes_state(struct rnd_state *state, void *buf, size_t bytes)
     102                 :            : {
     103                 :            :         u8 *ptr = buf;
     104                 :            : 
     105                 :          3 :         while (bytes >= sizeof(u32)) {
     106                 :          3 :                 put_unaligned(prandom_u32_state(state), (u32 *) ptr);
     107                 :          3 :                 ptr += sizeof(u32);
     108                 :          3 :                 bytes -= sizeof(u32);
     109                 :            :         }
     110                 :            : 
     111                 :          3 :         if (bytes > 0) {
     112                 :          0 :                 u32 rem = prandom_u32_state(state);
     113                 :            :                 do {
     114                 :          0 :                         *ptr++ = (u8) rem;
     115                 :          0 :                         bytes--;
     116                 :          0 :                         rem >>= BITS_PER_BYTE;
     117                 :          0 :                 } while (bytes > 0);
     118                 :            :         }
     119                 :          3 : }
     120                 :            : EXPORT_SYMBOL(prandom_bytes_state);
     121                 :            : 
     122                 :            : /**
     123                 :            :  *      prandom_bytes - get the requested number of pseudo-random bytes
     124                 :            :  *      @buf: where to copy the pseudo-random bytes to
     125                 :            :  *      @bytes: the requested number of bytes
     126                 :            :  */
     127                 :          3 : void prandom_bytes(void *buf, size_t bytes)
     128                 :            : {
     129                 :          3 :         struct rnd_state *state = &get_cpu_var(net_rand_state);
     130                 :            : 
     131                 :          3 :         prandom_bytes_state(state, buf, bytes);
     132                 :          3 :         put_cpu_var(net_rand_state);
     133                 :          3 : }
     134                 :            : EXPORT_SYMBOL(prandom_bytes);
     135                 :            : 
     136                 :          3 : static void prandom_warmup(struct rnd_state *state)
     137                 :            : {
     138                 :            :         /* Calling RNG ten times to satisfy recurrence condition */
     139                 :          3 :         prandom_u32_state(state);
     140                 :          3 :         prandom_u32_state(state);
     141                 :          3 :         prandom_u32_state(state);
     142                 :          3 :         prandom_u32_state(state);
     143                 :          3 :         prandom_u32_state(state);
     144                 :          3 :         prandom_u32_state(state);
     145                 :          3 :         prandom_u32_state(state);
     146                 :          3 :         prandom_u32_state(state);
     147                 :          3 :         prandom_u32_state(state);
     148                 :          3 :         prandom_u32_state(state);
     149                 :          3 : }
     150                 :            : 
     151                 :            : static u32 __extract_hwseed(void)
     152                 :            : {
     153                 :            :         unsigned int val = 0;
     154                 :            : 
     155                 :            :         (void)(arch_get_random_seed_int(&val) ||
     156                 :            :                arch_get_random_int(&val));
     157                 :            : 
     158                 :            :         return val;
     159                 :            : }
     160                 :            : 
     161                 :          3 : static void prandom_seed_early(struct rnd_state *state, u32 seed,
     162                 :            :                                bool mix_with_hwseed)
     163                 :            : {
     164                 :            : #define LCG(x)   ((x) * 69069U) /* super-duper LCG */
     165                 :            : #define HWSEED() (mix_with_hwseed ? __extract_hwseed() : 0)
     166                 :          3 :         state->s1 = __seed(HWSEED() ^ LCG(seed),        2U);
     167                 :          3 :         state->s2 = __seed(HWSEED() ^ LCG(state->s1),   8U);
     168                 :          3 :         state->s3 = __seed(HWSEED() ^ LCG(state->s2),  16U);
     169                 :          3 :         state->s4 = __seed(HWSEED() ^ LCG(state->s3), 128U);
     170                 :          3 : }
     171                 :            : 
     172                 :            : /**
     173                 :            :  *      prandom_seed - add entropy to pseudo random number generator
     174                 :            :  *      @entropy: entropy value
     175                 :            :  *
     176                 :            :  *      Add some additional entropy to the prandom pool.
     177                 :            :  */
     178                 :          3 : void prandom_seed(u32 entropy)
     179                 :            : {
     180                 :            :         int i;
     181                 :            :         /*
     182                 :            :          * No locking on the CPUs, but then somewhat random results are, well,
     183                 :            :          * expected.
     184                 :            :          */
     185                 :          3 :         for_each_possible_cpu(i) {
     186                 :          3 :                 struct rnd_state *state = &per_cpu(net_rand_state, i);
     187                 :            : 
     188                 :          3 :                 state->s1 = __seed(state->s1 ^ entropy, 2U);
     189                 :          3 :                 prandom_warmup(state);
     190                 :            :         }
     191                 :          3 : }
     192                 :            : EXPORT_SYMBOL(prandom_seed);
     193                 :            : 
     194                 :            : /*
     195                 :            :  *      Generate some initially weak seeding values to allow
     196                 :            :  *      to start the prandom_u32() engine.
     197                 :            :  */
     198                 :          3 : static int __init prandom_init(void)
     199                 :            : {
     200                 :            :         int i;
     201                 :            : 
     202                 :            :         prandom_state_selftest();
     203                 :            : 
     204                 :          3 :         for_each_possible_cpu(i) {
     205                 :          3 :                 struct rnd_state *state = &per_cpu(net_rand_state, i);
     206                 :          3 :                 u32 weak_seed = (i + jiffies) ^ random_get_entropy();
     207                 :            : 
     208                 :          3 :                 prandom_seed_early(state, weak_seed, true);
     209                 :          3 :                 prandom_warmup(state);
     210                 :            :         }
     211                 :            : 
     212                 :          3 :         return 0;
     213                 :            : }
     214                 :            : core_initcall(prandom_init);
     215                 :            : 
     216                 :            : static void __prandom_timer(struct timer_list *unused);
     217                 :            : 
     218                 :            : static DEFINE_TIMER(seed_timer, __prandom_timer);
     219                 :            : 
     220                 :          3 : static void __prandom_timer(struct timer_list *unused)
     221                 :            : {
     222                 :            :         u32 entropy;
     223                 :            :         unsigned long expires;
     224                 :            : 
     225                 :          3 :         get_random_bytes(&entropy, sizeof(entropy));
     226                 :          3 :         prandom_seed(entropy);
     227                 :            : 
     228                 :            :         /* reseed every ~60 seconds, in [40 .. 80) interval with slack */
     229                 :          3 :         expires = 40 + prandom_u32_max(40);
     230                 :          3 :         seed_timer.expires = jiffies + msecs_to_jiffies(expires * MSEC_PER_SEC);
     231                 :            : 
     232                 :          3 :         add_timer(&seed_timer);
     233                 :          3 : }
     234                 :            : 
     235                 :          3 : static void __init __prandom_start_seed_timer(void)
     236                 :            : {
     237                 :          3 :         seed_timer.expires = jiffies + msecs_to_jiffies(40 * MSEC_PER_SEC);
     238                 :          3 :         add_timer(&seed_timer);
     239                 :          3 : }
     240                 :            : 
     241                 :          3 : void prandom_seed_full_state(struct rnd_state __percpu *pcpu_state)
     242                 :            : {
     243                 :            :         int i;
     244                 :            : 
     245                 :          3 :         for_each_possible_cpu(i) {
     246                 :          3 :                 struct rnd_state *state = per_cpu_ptr(pcpu_state, i);
     247                 :            :                 u32 seeds[4];
     248                 :            : 
     249                 :          3 :                 get_random_bytes(&seeds, sizeof(seeds));
     250                 :          3 :                 state->s1 = __seed(seeds[0],   2U);
     251                 :          3 :                 state->s2 = __seed(seeds[1],   8U);
     252                 :          3 :                 state->s3 = __seed(seeds[2],  16U);
     253                 :          3 :                 state->s4 = __seed(seeds[3], 128U);
     254                 :            : 
     255                 :          3 :                 prandom_warmup(state);
     256                 :            :         }
     257                 :          3 : }
     258                 :            : EXPORT_SYMBOL(prandom_seed_full_state);
     259                 :            : 
     260                 :            : /*
     261                 :            :  *      Generate better values after random number generator
     262                 :            :  *      is fully initialized.
     263                 :            :  */
     264                 :          3 : static void __prandom_reseed(bool late)
     265                 :            : {
     266                 :            :         unsigned long flags;
     267                 :            :         static bool latch = false;
     268                 :            :         static DEFINE_SPINLOCK(lock);
     269                 :            : 
     270                 :            :         /* Asking for random bytes might result in bytes getting
     271                 :            :          * moved into the nonblocking pool and thus marking it
     272                 :            :          * as initialized. In this case we would double back into
     273                 :            :          * this function and attempt to do a late reseed.
     274                 :            :          * Ignore the pointless attempt to reseed again if we're
     275                 :            :          * already waiting for bytes when the nonblocking pool
     276                 :            :          * got initialized.
     277                 :            :          */
     278                 :            : 
     279                 :            :         /* only allow initial seeding (late == false) once */
     280                 :          3 :         if (!spin_trylock_irqsave(&lock, flags))
     281                 :          3 :                 return;
     282                 :            : 
     283                 :          3 :         if (latch && !late)
     284                 :            :                 goto out;
     285                 :            : 
     286                 :          3 :         latch = true;
     287                 :          3 :         prandom_seed_full_state(&net_rand_state);
     288                 :            : out:
     289                 :            :         spin_unlock_irqrestore(&lock, flags);
     290                 :            : }
     291                 :            : 
     292                 :          0 : void prandom_reseed_late(void)
     293                 :            : {
     294                 :          0 :         __prandom_reseed(true);
     295                 :          0 : }
     296                 :            : 
     297                 :          3 : static int __init prandom_reseed(void)
     298                 :            : {
     299                 :          3 :         __prandom_reseed(false);
     300                 :          3 :         __prandom_start_seed_timer();
     301                 :          3 :         return 0;
     302                 :            : }
     303                 :            : late_initcall(prandom_reseed);
     304                 :            : 
     305                 :            : #ifdef CONFIG_RANDOM32_SELFTEST
     306                 :            : static struct prandom_test1 {
     307                 :            :         u32 seed;
     308                 :            :         u32 result;
     309                 :            : } test1[] = {
     310                 :            :         { 1U, 3484351685U },
     311                 :            :         { 2U, 2623130059U },
     312                 :            :         { 3U, 3125133893U },
     313                 :            :         { 4U,  984847254U },
     314                 :            : };
     315                 :            : 
     316                 :            : static struct prandom_test2 {
     317                 :            :         u32 seed;
     318                 :            :         u32 iteration;
     319                 :            :         u32 result;
     320                 :            : } test2[] = {
     321                 :            :         /* Test cases against taus113 from GSL library. */
     322                 :            :         {  931557656U, 959U, 2975593782U },
     323                 :            :         { 1339693295U, 876U, 3887776532U },
     324                 :            :         { 1545556285U, 961U, 1615538833U },
     325                 :            :         {  601730776U, 723U, 1776162651U },
     326                 :            :         { 1027516047U, 687U,  511983079U },
     327                 :            :         {  416526298U, 700U,  916156552U },
     328                 :            :         { 1395522032U, 652U, 2222063676U },
     329                 :            :         {  366221443U, 617U, 2992857763U },
     330                 :            :         { 1539836965U, 714U, 3783265725U },
     331                 :            :         {  556206671U, 994U,  799626459U },
     332                 :            :         {  684907218U, 799U,  367789491U },
     333                 :            :         { 2121230701U, 931U, 2115467001U },
     334                 :            :         { 1668516451U, 644U, 3620590685U },
     335                 :            :         {  768046066U, 883U, 2034077390U },
     336                 :            :         { 1989159136U, 833U, 1195767305U },
     337                 :            :         {  536585145U, 996U, 3577259204U },
     338                 :            :         { 1008129373U, 642U, 1478080776U },
     339                 :            :         { 1740775604U, 939U, 1264980372U },
     340                 :            :         { 1967883163U, 508U,   10734624U },
     341                 :            :         { 1923019697U, 730U, 3821419629U },
     342                 :            :         {  442079932U, 560U, 3440032343U },
     343                 :            :         { 1961302714U, 845U,  841962572U },
     344                 :            :         { 2030205964U, 962U, 1325144227U },
     345                 :            :         { 1160407529U, 507U,  240940858U },
     346                 :            :         {  635482502U, 779U, 4200489746U },
     347                 :            :         { 1252788931U, 699U,  867195434U },
     348                 :            :         { 1961817131U, 719U,  668237657U },
     349                 :            :         { 1071468216U, 983U,  917876630U },
     350                 :            :         { 1281848367U, 932U, 1003100039U },
     351                 :            :         {  582537119U, 780U, 1127273778U },
     352                 :            :         { 1973672777U, 853U, 1071368872U },
     353                 :            :         { 1896756996U, 762U, 1127851055U },
     354                 :            :         {  847917054U, 500U, 1717499075U },
     355                 :            :         { 1240520510U, 951U, 2849576657U },
     356                 :            :         { 1685071682U, 567U, 1961810396U },
     357                 :            :         { 1516232129U, 557U,    3173877U },
     358                 :            :         { 1208118903U, 612U, 1613145022U },
     359                 :            :         { 1817269927U, 693U, 4279122573U },
     360                 :            :         { 1510091701U, 717U,  638191229U },
     361                 :            :         {  365916850U, 807U,  600424314U },
     362                 :            :         {  399324359U, 702U, 1803598116U },
     363                 :            :         { 1318480274U, 779U, 2074237022U },
     364                 :            :         {  697758115U, 840U, 1483639402U },
     365                 :            :         { 1696507773U, 840U,  577415447U },
     366                 :            :         { 2081979121U, 981U, 3041486449U },
     367                 :            :         {  955646687U, 742U, 3846494357U },
     368                 :            :         { 1250683506U, 749U,  836419859U },
     369                 :            :         {  595003102U, 534U,  366794109U },
     370                 :            :         {   47485338U, 558U, 3521120834U },
     371                 :            :         {  619433479U, 610U, 3991783875U },
     372                 :            :         {  704096520U, 518U, 4139493852U },
     373                 :            :         { 1712224984U, 606U, 2393312003U },
     374                 :            :         { 1318233152U, 922U, 3880361134U },
     375                 :            :         {  855572992U, 761U, 1472974787U },
     376                 :            :         {   64721421U, 703U,  683860550U },
     377                 :            :         {  678931758U, 840U,  380616043U },
     378                 :            :         {  692711973U, 778U, 1382361947U },
     379                 :            :         {  677703619U, 530U, 2826914161U },
     380                 :            :         {   92393223U, 586U, 1522128471U },
     381                 :            :         { 1222592920U, 743U, 3466726667U },
     382                 :            :         {  358288986U, 695U, 1091956998U },
     383                 :            :         { 1935056945U, 958U,  514864477U },
     384                 :            :         {  735675993U, 990U, 1294239989U },
     385                 :            :         { 1560089402U, 897U, 2238551287U },
     386                 :            :         {   70616361U, 829U,   22483098U },
     387                 :            :         {  368234700U, 731U, 2913875084U },
     388                 :            :         {   20221190U, 879U, 1564152970U },
     389                 :            :         {  539444654U, 682U, 1835141259U },
     390                 :            :         { 1314987297U, 840U, 1801114136U },
     391                 :            :         { 2019295544U, 645U, 3286438930U },
     392                 :            :         {  469023838U, 716U, 1637918202U },
     393                 :            :         { 1843754496U, 653U, 2562092152U },
     394                 :            :         {  400672036U, 809U, 4264212785U },
     395                 :            :         {  404722249U, 965U, 2704116999U },
     396                 :            :         {  600702209U, 758U,  584979986U },
     397                 :            :         {  519953954U, 667U, 2574436237U },
     398                 :            :         { 1658071126U, 694U, 2214569490U },
     399                 :            :         {  420480037U, 749U, 3430010866U },
     400                 :            :         {  690103647U, 969U, 3700758083U },
     401                 :            :         { 1029424799U, 937U, 3787746841U },
     402                 :            :         { 2012608669U, 506U, 3362628973U },
     403                 :            :         { 1535432887U, 998U,   42610943U },
     404                 :            :         { 1330635533U, 857U, 3040806504U },
     405                 :            :         { 1223800550U, 539U, 3954229517U },
     406                 :            :         { 1322411537U, 680U, 3223250324U },
     407                 :            :         { 1877847898U, 945U, 2915147143U },
     408                 :            :         { 1646356099U, 874U,  965988280U },
     409                 :            :         {  805687536U, 744U, 4032277920U },
     410                 :            :         { 1948093210U, 633U, 1346597684U },
     411                 :            :         {  392609744U, 783U, 1636083295U },
     412                 :            :         {  690241304U, 770U, 1201031298U },
     413                 :            :         { 1360302965U, 696U, 1665394461U },
     414                 :            :         { 1220090946U, 780U, 1316922812U },
     415                 :            :         {  447092251U, 500U, 3438743375U },
     416                 :            :         { 1613868791U, 592U,  828546883U },
     417                 :            :         {  523430951U, 548U, 2552392304U },
     418                 :            :         {  726692899U, 810U, 1656872867U },
     419                 :            :         { 1364340021U, 836U, 3710513486U },
     420                 :            :         { 1986257729U, 931U,  935013962U },
     421                 :            :         {  407983964U, 921U,  728767059U },
     422                 :            : };
     423                 :            : 
     424                 :            : static void __init prandom_state_selftest(void)
     425                 :            : {
     426                 :            :         int i, j, errors = 0, runs = 0;
     427                 :            :         bool error = false;
     428                 :            : 
     429                 :            :         for (i = 0; i < ARRAY_SIZE(test1); i++) {
     430                 :            :                 struct rnd_state state;
     431                 :            : 
     432                 :            :                 prandom_seed_early(&state, test1[i].seed, false);
     433                 :            :                 prandom_warmup(&state);
     434                 :            : 
     435                 :            :                 if (test1[i].result != prandom_u32_state(&state))
     436                 :            :                         error = true;
     437                 :            :         }
     438                 :            : 
     439                 :            :         if (error)
     440                 :            :                 pr_warn("prandom: seed boundary self test failed\n");
     441                 :            :         else
     442                 :            :                 pr_info("prandom: seed boundary self test passed\n");
     443                 :            : 
     444                 :            :         for (i = 0; i < ARRAY_SIZE(test2); i++) {
     445                 :            :                 struct rnd_state state;
     446                 :            : 
     447                 :            :                 prandom_seed_early(&state, test2[i].seed, false);
     448                 :            :                 prandom_warmup(&state);
     449                 :            : 
     450                 :            :                 for (j = 0; j < test2[i].iteration - 1; j++)
     451                 :            :                         prandom_u32_state(&state);
     452                 :            : 
     453                 :            :                 if (test2[i].result != prandom_u32_state(&state))
     454                 :            :                         errors++;
     455                 :            : 
     456                 :            :                 runs++;
     457                 :            :                 cond_resched();
     458                 :            :         }
     459                 :            : 
     460                 :            :         if (errors)
     461                 :            :                 pr_warn("prandom: %d/%d self tests failed\n", errors, runs);
     462                 :            :         else
     463                 :            :                 pr_info("prandom: %d self tests passed\n", runs);
     464                 :            : }
     465                 :            : #endif
    

Generated by: LCOV version 1.14