updates

Author: newpavlov

src/dragonfly_haiku_emscripten.rs

@@ -133,10 +133,6 @@ extern crate wasm_bindgen;
 #[allow(unused)]
 #[cfg(not(feature = "log"))] macro_rules! error { ($($x:tt)*) => () }
 
-#[cfg(any(
-    target_arch = "wasm32",
-))]
-mod utils;
 mod error;
 pub use error::Error;
 
@@ -156,17 +152,17 @@ macro_rules! mod_use {
 mod_use!(cfg(target_os = "android"), linux_android);
 mod_use!(cfg(target_os = "bitrig"), openbsd_bitrig);
 mod_use!(cfg(target_os = "cloudabi"), cloudabi);
-mod_use!(cfg(target_os = "dragonfly"), dragonfly_haiku_emscripten);
-mod_use!(cfg(target_os = "emscripten"), dragonfly_haiku_emscripten);
+mod_use!(cfg(target_os = "dragonfly"), use_file);
+mod_use!(cfg(target_os = "emscripten"), use_file);
 mod_use!(cfg(target_os = "freebsd"), freebsd);
 mod_use!(cfg(target_os = "fuchsia"), fuchsia);
-mod_use!(cfg(target_os = "haiku"), dragonfly_haiku_emscripten);
+mod_use!(cfg(target_os = "haiku"), use_file);
 mod_use!(cfg(target_os = "ios"), macos);
 mod_use!(cfg(target_os = "linux"), linux_android);
 mod_use!(cfg(target_os = "macos"), macos);
-mod_use!(cfg(target_os = "netbsd"), netbsd);
+mod_use!(cfg(target_os = "netbsd"), use_file);
 mod_use!(cfg(target_os = "openbsd"), openbsd_bitrig);
-mod_use!(cfg(target_os = "redox"), redox);
+mod_use!(cfg(target_os = "redox"), use_file);
 mod_use!(cfg(target_os = "solaris"), solaris);
 mod_use!(cfg(target_os = "illumos"), solaris);
 mod_use!(cfg(windows), windows);

src/lib.rs

@@ -11,16 +11,16 @@ extern crate libc;
 
 use Error;
 use std::fs::File;
-use std::{io, mem, thread};
 use std::io::Read;
 use std::num::NonZeroU32;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicIsize, AtomicUsize, Ordering};
 use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::{io, mem, thread, time};
 
 // replace with AtomicU8 on stabilization and MSRV bump
 static RNG_STATE: AtomicUsize = AtomicUsize::new(0);
 // replace with AtomicI32 on stabilization and MSRV bump
-static RNG_FD: AtomicUsize = AtomicUsize::new(0);
+static RNG_FD: AtomicIsize = AtomicIsize::new(-1);
 
 const STATE_INIT_ONGOING: usize = 1 << 0;
 const STATE_USE_SYSCALL: usize = 1 << 1;
@@ -42,7 +42,8 @@ fn init_loop(dest: &mut [u8]) -> Result<(), Error> {
         let state = RNG_STATE.fetch_or(STATE_INIT_ONGOING, Ordering::AcqRel);
 
         if state & STATE_INIT_ONGOING != 0 {
-            thread::yield_now();
+            // initialization is not finished, so wait
+            thread::sleep(time::Duration::from_nanos(1));
             continue;
         }
         return if state & STATE_USE_SYSCALL != 0 {
@@ -64,8 +65,8 @@ fn init(dest: &mut [u8]) -> Result<(), Error> {
         Err(err) if err.code().get() as i32 == libc::ENOSYS => {
             match init_fd() {
                 Ok(fd) => {
-                    RNG_FD.store(fd as usize, Ordering::Release);
-                    RNG_STATE.store(STATE_USE_FD, Ordering::Release);
+                    RNG_FD.store(fd as isize, Ordering::SeqCst);
+                    RNG_STATE.store(STATE_USE_FD, Ordering::SeqCst);
                     use_fd(dest)
                 },
                 Err(err) => {
@@ -79,6 +80,7 @@ fn init(dest: &mut [u8]) -> Result<(), Error> {
 }
 
 fn init_fd() -> io::Result<i32> {
+    // read one byte from "/dev/random" to ensure that OS RNG has initialized
     File::open("/dev/random")?.read_exact(&mut [0u8; 1])?;
     let f = File::open("/dev/urandom")?;
     let fd = f.as_raw_fd();

src/linux_android.rs

@@ -23,9 +23,9 @@ use Error;
 use std::fs::File;
 use std::io::Read;
 use std::num::NonZeroU32;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicIsize, AtomicUsize, Ordering};
 use std::os::unix::io::{RawFd, AsRawFd, FromRawFd};
-use std::{io, mem, thread};
+use std::{io, mem, thread, time};
 
 #[cfg(target_os = "illumos")]
 type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) -> libc::ssize_t;
@@ -34,7 +34,7 @@ type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) ->
 
 static RNG_FN: AtomicUsize = AtomicUsize::new(0);
 // replace with AtomicI32 on stabilization and MSRV bump
-static RNG_FD: AtomicUsize = AtomicUsize::new(-1i32 as usize);
+static RNG_FD: AtomicIsize = AtomicIsize::new(-1);
 // replace with AtomicU8 on stabilization and MSRV bump
 static RNG_STATE: AtomicUsize = AtomicUsize::new(0);
 
@@ -57,7 +57,7 @@ pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
         if state & STATE_INIT_DONE != 0 { break; }
         if state & STATE_INIT_ONGOING != 0 {
             // initialization is not finished, so wait
-            thread::yield_now();
+            thread::sleep(time::Duration::from_nanos(1));
             continue;
         }
 
@@ -70,12 +70,12 @@ pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
                     return Err(err.into());
                 },
             };
-            RNG_FD.store(f.as_raw_fd() as usize, Ordering::Release);
+            RNG_FD.store(f.as_raw_fd() as isize, Ordering::SeqCst);
             mem::forget(f);
         } else {
-            RNG_FN.store(f, Ordering::Release);
+            RNG_FN.store(f, Ordering::SeqCst);
         }
-        RNG_STATE.store(STATE_INIT_DONE, Ordering::Release);
+        RNG_STATE.store(STATE_INIT_DONE, Ordering::SeqCst);
         break;
     }