stdlib/tst-arc4random-thread.c

   1 /* Test that threads generate distinct streams of randomness.
   2    Copyright (C) 2022-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <array_length.h>
  20 #include <sched.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <support/check.h>
  25 #include <support/namespace.h>
  26 #include <support/support.h>
  27 #include <support/xthread.h>
  28
  29 /* Number of arc4random_buf calls per thread.  */
  30 enum { count_per_thread = 2048 };
  31
  32 /* Number of threads computing randomness.  */
  33 enum { inner_threads = 4 };
  34
  35 /* Number of threads launching other threads.  */
  36 static int outer_threads = 1;
  37
  38 /* Number of launching rounds performed by the outer threads.  */
  39 enum { outer_rounds = 10 };
  40
  41 /* Maximum number of bytes generated in an arc4random call.  */
  42 enum { max_size = 32 };
  43
  44 /* Sizes generated by threads.  Must be long enough to be unique with
  45    high probability.  */
  46 static const int sizes[] = { 12, 15, 16, 17, 24, 31, max_size };
  47
  48 /* Data structure to capture randomness results.  */
  49 struct blob
  50 {
  51   unsigned int size;
  52   int thread_id;
  53   unsigned int index;
  54   unsigned char bytes[max_size];
  55 };
  56
  57 struct subprocess_args
  58 {
  59   struct blob *blob;
  60   void (*func)(unsigned char *, size_t);
  61 };
  62
  63 static void
  64 generate_arc4random (unsigned char *bytes, size_t size)
  65 {
  66   int i;
  67   for (i = 0; i < size / sizeof (uint32_t); i++)
  68     {
  69       uint32_t x = arc4random ();
  70       memcpy (&bytes[4 * i], &x, sizeof x);
  71     }
  72   int rem = size % sizeof (uint32_t);
  73   if (rem > 0)
  74     {
  75       uint32_t x = arc4random ();
  76       memcpy (&bytes[4 * i], &x, rem);
  77     }
  78 }
  79
  80 static void
  81 generate_arc4random_buf (unsigned char *bytes, size_t size)
  82 {
  83   arc4random_buf (bytes, size);
  84 }
  85
  86 static void
  87 generate_arc4random_uniform (unsigned char *bytes, size_t size)
  88 {
  89   for (int i = 0; i < size; i++)
  90     bytes[i] = arc4random_uniform (256);
  91 }
  92
  93 #define DYNARRAY_STRUCT dynarray_blob
  94 #define DYNARRAY_ELEMENT struct blob
  95 #define DYNARRAY_PREFIX dynarray_blob_
  96 #include <malloc/dynarray-skeleton.c>
  97
  98 /* Sort blob elements by length first, then by comparing the data
  99    member.  */
 100 static int
 101 compare_blob (const void *left1, const void *right1)
 102 {
 103   const struct blob *left = left1;
 104   const struct blob *right = right1;
 105
 106   if (left->size != right->size)
 107     /* No overflow due to limited range.  */
 108     return left->size - right->size;
 109   return memcmp (left->bytes, right->bytes, left->size);
 110 }
 111
 112 /* Used to store the global result.  */
 113 static pthread_mutex_t global_result_lock = PTHREAD_MUTEX_INITIALIZER;
 114 static struct dynarray_blob global_result;
 115
 116 /* Copy data to the global result, with locking.  */
 117 static void
 118 copy_result_to_global (struct dynarray_blob *result)
 119 {
 120   xpthread_mutex_lock (&global_result_lock);
 121   size_t old_size = dynarray_blob_size (&global_result);
 122   TEST_VERIFY_EXIT
 123     (dynarray_blob_resize (&global_result,
 124                            old_size + dynarray_blob_size (result)));
 125   memcpy (dynarray_blob_begin (&global_result) + old_size,
 126           dynarray_blob_begin (result),
 127           dynarray_blob_size (result) * sizeof (struct blob));
 128   xpthread_mutex_unlock (&global_result_lock);
 129 }
 130
 131 /* Used to assign unique thread IDs.  Accessed atomically.  */
 132 static int next_thread_id;
 133
 134 static void *
 135 inner_thread (void *closure)
 136 {
 137   void (*func) (unsigned char *, size_t) = closure;
 138
 139   /* Use local result to avoid global lock contention while generating
 140      randomness.  */
 141   struct dynarray_blob result;
 142   dynarray_blob_init (&result);
 143
 144   int thread_id = __atomic_fetch_add (&next_thread_id, 1, __ATOMIC_RELAXED);
 145
 146   /* Determine the sizes to be used by this thread.  */
 147   int size_slot = thread_id % (array_length (sizes) + 1);
 148   bool switch_sizes = size_slot == array_length (sizes);
 149   if (switch_sizes)
 150     size_slot = 0;
 151
 152   /* Compute the random blobs.  */
 153   for (int i = 0; i < count_per_thread; ++i)
 154     {
 155       struct blob *place = dynarray_blob_emplace (&result);
 156       TEST_VERIFY_EXIT (place != NULL);
 157       place->size = sizes[size_slot];
 158       place->thread_id = thread_id;
 159       place->index = i;
 160       func (place->bytes, place->size);
 161
 162       if (switch_sizes)
 163         size_slot = (size_slot + 1) % array_length (sizes);
 164     }
 165
 166   /* Store the blobs in the global result structure.  */
 167   copy_result_to_global (&result);
 168
 169   dynarray_blob_free (&result);
 170
 171   return NULL;
 172 }
 173
 174 /* Launch the inner threads and wait for their termination.  */
 175 static void *
 176 outer_thread (void *closure)
 177 {
 178   void (*func) (unsigned char *, size_t) = closure;
 179
 180   for (int round = 0; round < outer_rounds; ++round)
 181     {
 182       pthread_t threads[inner_threads];
 183
 184       for (int i = 0; i < inner_threads; ++i)
 185         threads[i] = xpthread_create (NULL, inner_thread, func);
 186
 187       for (int i = 0; i < inner_threads; ++i)
 188         xpthread_join (threads[i]);
 189     }
 190
 191   return NULL;
 192 }
 193
 194 static bool termination_requested;
 195
 196 /* Call arc4random_buf to fill one blob with 16 bytes.  */
 197 static void *
 198 get_one_blob_thread (void *closure)
 199 {
 200   struct subprocess_args *arg = closure;
 201   struct blob *result = arg->blob;
 202
 203   result->size = 16;
 204   arg->func (result->bytes, result->size);
 205   return NULL;
 206 }
 207
 208 /* Invoked from fork_thread to actually obtain randomness data.  */
 209 static void
 210 fork_thread_subprocess (void *closure)
 211 {
 212   struct subprocess_args *arg = closure;
 213   struct blob *shared_result = arg->blob;
 214
 215   struct subprocess_args args[3] =
 216   {
 217     { shared_result + 0, arg->func },
 218     { shared_result + 1, arg->func },
 219     { shared_result + 2, arg->func }
 220   };
 221
 222   pthread_t thr1 = xpthread_create (NULL, get_one_blob_thread, &args[1]);
 223   pthread_t thr2 = xpthread_create (NULL, get_one_blob_thread, &args[2]);
 224   get_one_blob_thread (&args[0]);
 225   xpthread_join (thr1);
 226   xpthread_join (thr2);
 227 }
 228
 229 /* Continuously fork subprocesses to obtain a little bit of
 230    randomness.  */
 231 static void *
 232 fork_thread (void *closure)
 233 {
 234   void (*func)(unsigned char *, size_t) = closure;
 235
 236   struct dynarray_blob result;
 237   dynarray_blob_init (&result);
 238
 239   /* Three blobs from each subprocess.  */
 240   struct blob *shared_result
 241     = support_shared_allocate (3 * sizeof (*shared_result));
 242
 243   while (!__atomic_load_n (&termination_requested, __ATOMIC_RELAXED))
 244     {
 245       /* Obtain the results from a subprocess.  */
 246       struct subprocess_args arg = { shared_result, func };
 247       support_isolate_in_subprocess (fork_thread_subprocess, &arg);
 248
 249       for (int i = 0; i < 3; ++i)
 250         {
 251           struct blob *place = dynarray_blob_emplace (&result);
 252           TEST_VERIFY_EXIT (place != NULL);
 253           place->size = shared_result[i].size;
 254           place->thread_id = -1;
 255           place->index = i;
 256           memcpy (place->bytes, shared_result[i].bytes, place->size);
 257         }
 258     }
 259
 260   support_shared_free (shared_result);
 261
 262   copy_result_to_global (&result);
 263   dynarray_blob_free (&result);
 264
 265   return NULL;
 266 }
 267
 268 /* Launch the outer threads and wait for their termination.  */
 269 static void
 270 run_outer_threads (void (*func)(unsigned char *, size_t))
 271 {
 272   /* Special thread that continuously calls fork.  */
 273   pthread_t fork_thread_id = xpthread_create (NULL, fork_thread, func);
 274
 275   pthread_t threads[outer_threads];
 276   for (int i = 0; i < outer_threads; ++i)
 277     threads[i] = xpthread_create (NULL, outer_thread, func);
 278
 279   for (int i = 0; i < outer_threads; ++i)
 280     xpthread_join (threads[i]);
 281
 282   __atomic_store_n (&termination_requested, true, __ATOMIC_RELAXED);
 283   xpthread_join (fork_thread_id);
 284 }
 285
 286 static int
 287 do_test_func (const char *fname, void (*func)(unsigned char *, size_t))
 288 {
 289   dynarray_blob_init (&global_result);
 290   int expected_blobs
 291     = count_per_thread * inner_threads * outer_threads * outer_rounds;
 292   printf ("info: %s: minimum of %d blob results expected\n",
 293           fname, expected_blobs);
 294
 295   run_outer_threads (func);
 296
 297   /* The forking thread delivers a non-deterministic number of
 298      results, which is why expected_blobs is only a minimum number of
 299      results.  */
 300   printf ("info: %s: %zu blob results observed\n", fname,
 301           dynarray_blob_size (&global_result));
 302   TEST_VERIFY (dynarray_blob_size (&global_result) >= expected_blobs);
 303
 304   /* Verify that there are no duplicates.  */
 305   qsort (dynarray_blob_begin (&global_result),
 306          dynarray_blob_size (&global_result),
 307          sizeof (struct blob), compare_blob);
 308   struct blob *end = dynarray_blob_end (&global_result);
 309   for (struct blob *p = dynarray_blob_begin (&global_result) + 1;
 310        p < end; ++p)
 311     {
 312       if (compare_blob (p - 1, p) == 0)
 313         {
 314           support_record_failure ();
 315           char *quoted = support_quote_blob (p->bytes, p->size);
 316           printf ("error: %s: duplicate blob: \"%s\" (%d bytes)\n",
 317                   fname, quoted, (int) p->size);
 318           printf ("  first source: thread %d, index %u\n",
 319                   p[-1].thread_id, p[-1].index);
 320           printf ("  second source: thread %d, index %u\n",
 321                   p[0].thread_id, p[0].index);
 322           free (quoted);
 323         }
 324     }
 325
 326   dynarray_blob_free (&global_result);
 327
 328   return 0;
 329 }
 330
 331 static int
 332 do_test (void)
 333 {
 334   /* Do not run more threads than the maximum of schedulable CPUs.  */
 335   cpu_set_t cpuset;
 336   if (sched_getaffinity (0, sizeof cpuset, &cpuset) == 0)
 337     {
 338       unsigned int ncpus = CPU_COUNT (&cpuset);
 339       /* Limit the number to not overload the system.  */
 340       outer_threads = (ncpus / 2) / inner_threads ?: 1;
 341     }
 342
 343   printf ("info: outer_threads=%d inner_threads=%d\n", outer_threads,
 344           inner_threads);
 345
 346   do_test_func ("arc4random", generate_arc4random);
 347   do_test_func ("arc4random_buf", generate_arc4random_buf);
 348   do_test_func ("arc4random_uniform", generate_arc4random_uniform);
 349
 350   return 0;
 351 }
 352
 353 #include <support/test-driver.c>