[libc++] Use ioctl when available to get random_device entropy.

[curdeius]

Summary

Implemented the idea from D94571 to improve entropy on Linux.

[curdeius]

libcxx/src/random.cpp

180

This could be guarded even more if we wanted. E.g. defining _LIBCPP_USING_IOCTL/LINUX_RANDOM_H, but personally I think that just checking for RNDGETENTCNT is enough.

[ldionne]

@tcanens You may want to consider updating cppreference in light of this patch when it gets in.

This LGTM except for the test nitpick!

libcxx/test/std/numerics/rand/rand.device/entropy.pass.cpp

26–27

I think we want to make those be LIBCPP_ASSERT(...) instead, since the entropy is technically not mandated by the standard. It's just that our implementation behaves that way.

[ldionne]

libcxx/src/random.cpp

33

Should this be __has_include(<sys/ioctl.h>) instead?

[curdeius]

libcxx/src/random.cpp

33

Oops, good catch.

libcxx/test/std/numerics/rand/rand.device/entropy.pass.cpp

26–27

The standard says this http://eel.is/c++draft/rand.device#5. So entropy should be between min and log2(max+1), where max is max of result_type.
At the same time, http://eel.is/c++draft/rand.device#2 says result_type=unsigned int.
So the only thing that can change is the size of unsigned int (which can be non-32-bit somewhere).
To be precise I should rather assert(e <= sizeof(result_type) * CHAR_BIT).
And it should be for whatever implementation of stdlib.
WDYT?

[curdeius]

Fix has_include. Use result_type.

[ldionne]

LGTM, thanks!

libcxx/src/random.cpp

 //===-------------------------- random.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <__config>
 
 #if defined(_LIBCPP_USING_WIN32_RANDOM)
 // Must be defined before including stdlib.h to enable rand_s().
 #define _CRT_RAND_S
 #endif // defined(_LIBCPP_USING_WIN32_RANDOM)
 
+#include "limits"
 #include "random"
 #include "system_error"
 
 #if defined(__sun__)
 #define rename solaris_headers_are_broken
 #endif // defined(__sun__)
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #if defined(_LIBCPP_USING_GETENTROPY)
 #include <sys/random.h>
 #elif defined(_LIBCPP_USING_DEV_RANDOM)
 #include <fcntl.h>
 #include <unistd.h>
+#if __has_include(<sys/ioctl.h>) && __has_include(<linux/random.h>)
+#include <sys/ioctl.h>
+#include <linux/random.h>
+#endif
 #elif defined(_LIBCPP_USING_NACL_RANDOM)
 #include <nacl/nacl_random.h>
 #endif
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(_LIBCPP_USING_GETENTROPY)

 
 #else
 #error "Random device not implemented for this architecture"
 #endif
 
 double
 random_device::entropy() const _NOEXCEPT
 {
-    return 0;
+#if defined(_LIBCPP_USING_DEV_RANDOM) && defined(RNDGETENTCNT)
+  int ent;
+  if (::ioctl(__f_, RNDGETENTCNT, &ent) < 0)
+    return 0;
+
+  if (ent < 0)
+    return 0;
+
+  if (ent > std::numeric_limits<result_type>::digits)
+    return std::numeric_limits<result_type>::digits;
+
+  return ent;
+#else
+#endif
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/std/numerics/rand/rand.device/entropy.pass.cpp

 // <random>
 
 // class random_device;
 
 // double entropy() const;
 
 #include <random>
 #include <cassert>
+#include <climits>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    std::random_device r;
-    double e = r.entropy();
-    ((void)e); // Prevent unused warning
+int main(int, char**) {
+  assert(e >= 0);
+  assert(e <= sizeof(typename std::random_device::result_type) * CHAR_BIT);
 
   return 0;
 }