remove TLS

Author: newpavlov

src/dragonfly_haiku.rs

@@ -0,0 +1,87 @@
+// Copyright 2018 Developers of the Rand project.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Implementation for DragonFly / Haiku
+use Error;
+use std::fs::File;
+use std::io::Read;
+use std::num::NonZeroU32;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::os::unix::io::{RawFd, AsRawFd, FromRawFd};
+use std::{thread, mem};
+
+// replace with AtomicI32 on stabilization and MSRV bump
+static RNG_FD: AtomicUsize = AtomicUsize::new(-1i32 as usize);
+// replace with AtomicU8 on stabilization and MSRV bump
+static RNG_STATE: AtomicUsize = AtomicUsize::new(0);
+
+const STATE_INIT_ONGOING: usize = 1 << 0;
+const STATE_INIT_DONE: usize = 1 << 1;
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+    let fd = RNG_FD.load(Ordering::Acquire) as i32;
+    if fd >= 0 {
+        return use_fd(fd, dest);
+    }
+    let fd = loop {
+        let state = RNG_STATE.fetch_or(STATE_INIT_ONGOING, Ordering::AcqRel);
+        if state & STATE_INIT_DONE != 0 {
+            // initialization is complete, use fd from atomic
+            break RNG_FD.load(Ordering::Acquire) as RawFd;
+        } else if state & STATE_INIT_ONGOING == 0 {
+            // start initialization and return resulting fd
+            match init_fd() {
+                Ok(fd) => {
+                    RNG_STATE.store(STATE_INIT_DONE, Ordering::Release);
+                    RNG_FD.store(fd as usize, Ordering::Release);
+                    break fd
+                },
+                Err(err) => {
+                    RNG_STATE.store(0, Ordering::Release);
+                    return Err(err);
+                }
+            }
+        }
+        // initialization is not finished, so wait
+        thread::yield_now();
+    };
+    use_fd(fd, dest)
+}
+
+#[cfg(not(target_os = "emscripten"))]
+fn use_fd(fd: RawFd, dest: &mut [u8]) -> Result<(), Error> {
+    let mut f = unsafe { File::from_raw_fd(fd) };
+    f.read_exact(dest)?;
+    mem::forget(f);
+    Ok(())
+}
+
+#[cfg(target_os = "emscripten")]
+fn use_fd(fd: RawFd, dest: &mut [u8]) -> Result<(), Error> {
+    let mut f = unsafe { File::from_raw_fd(fd) };
+    // `Crypto.getRandomValues` documents `dest` should be at most 65536
+    // bytes. `crypto.randomBytes` documents: "To minimize threadpool
+    // task length variation, partition large randomBytes requests when
+    // doing so as part of fulfilling a client request.
+    for chunk in dest.chunks_mut(65536) {
+        f.read_exact(chunk)?;
+    }
+    mem::forget(f);
+    Ok(())
+}
+
+fn init_fd() -> Result<RawFd, Error> {
+    let f = File::open("/dev/random")?;
+    let fd = f.as_raw_fd();
+    RNG_FD.store(fd as usize, Ordering::Release);
+    mem::forget(f);
+    Ok(fd)
+}
+
+#[inline(always)]
+pub fn error_msg_inner(_: NonZeroU32) -> Option<&'static str> { None }

src/dragonfly_haiku_emscripten.rs

@@ -134,14 +134,6 @@ extern crate wasm_bindgen;
 #[cfg(not(feature = "log"))] macro_rules! error { ($($x:tt)*) => () }
 
 #[cfg(any(
-    target_os = "android",
-    target_os = "netbsd",
-    target_os = "solaris",
-    target_os = "illumos",
-    target_os = "redox",
-    target_os = "dragonfly",
-    target_os = "haiku",
-    target_os = "linux",
     target_arch = "wasm32",
 ))]
 mod utils;
@@ -164,18 +156,19 @@ 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);
-mod_use!(cfg(target_os = "emscripten"), emscripten);
+mod_use!(cfg(target_os = "dragonfly"), dragonfly_haiku_emscripten);
+mod_use!(cfg(target_os = "emscripten"), dragonfly_haiku_emscripten);
 mod_use!(cfg(target_os = "freebsd"), freebsd);
 mod_use!(cfg(target_os = "fuchsia"), fuchsia);
-mod_use!(cfg(target_os = "haiku"), dragonfly_haiku);
+mod_use!(cfg(target_os = "haiku"), dragonfly_haiku_emscripten);
 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 = "openbsd"), openbsd_bitrig);
 mod_use!(cfg(target_os = "redox"), redox);
-mod_use!(cfg(any(target_os = "solaris", target_os = "illumos")), solarish);
+mod_use!(cfg(target_os = "solaris"), solaris);
+mod_use!(cfg(target_os = "illumos"), solaris);
 mod_use!(cfg(windows), windows);
 mod_use!(cfg(target_env = "sgx"), sgx);
 

src/emscripten.rs

@@ -10,77 +10,100 @@
 extern crate libc;
 
 use Error;
-use utils::use_init;
 use std::fs::File;
-use std::io;
+use std::{io, mem, thread};
 use std::io::Read;
-use std::cell::RefCell;
 use std::num::NonZeroU32;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::os::unix::io::{AsRawFd, FromRawFd};
 
-static RNG_INIT: AtomicBool = AtomicBool::new(false);
+// 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);
 
-enum RngSource {
-    GetRandom,
-    Device(File),
+const STATE_INIT_ONGOING: usize = 1 << 0;
+const STATE_USE_SYSCALL: usize = 1 << 1;
+const STATE_USE_FD: usize = 1 << 2;
+
+pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
+    let state = RNG_STATE.load(Ordering::Acquire);
+    if state & STATE_USE_SYSCALL != 0 {
+        use_syscall(dest)
+    } else if state & STATE_USE_FD != 0 {
+        use_fd(dest)
+    } else {
+        init_loop(dest)
+    }
 }
 
-thread_local!(
-    static RNG_SOURCE: RefCell<Option<RngSource>> = RefCell::new(None);
-);
+fn init_loop(dest: &mut [u8]) -> Result<(), Error> {
+    loop {
+        let state = RNG_STATE.fetch_or(STATE_INIT_ONGOING, Ordering::AcqRel);
 
-fn syscall_getrandom(dest: &mut [u8]) -> Result<(), io::Error> {
-    let ret = unsafe {
-        libc::syscall(libc::SYS_getrandom, dest.as_mut_ptr(), dest.len(), 0)
-    };
-    if ret < 0 || (ret as usize) != dest.len() {
-        error!("Linux getrandom syscall failed with return value {}", ret);
-        return Err(io::Error::last_os_error());
+        if state & STATE_INIT_ONGOING != 0 {
+            thread::yield_now();
+            continue;
+        }
+        return if state & STATE_USE_SYSCALL != 0 {
+            use_syscall(dest)
+        } else if state & STATE_USE_FD != 0 {
+            use_fd(dest)
+        } else {
+            init(dest)
+        };
     }
-    Ok(())
 }
 
-pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    RNG_SOURCE.with(|f| {
-        use_init(f,
-        || {
-            let s = if is_getrandom_available() {
-                RngSource::GetRandom
-            } else {
-                // read one byte from "/dev/random" to ensure that
-                // OS RNG has initialized
-                if !RNG_INIT.load(Ordering::Relaxed) {
-                    File::open("/dev/random")?.read_exact(&mut [0u8; 1])?;
-                    RNG_INIT.store(true, Ordering::Relaxed)
+fn init(dest: &mut [u8]) -> Result<(), Error> {
+    match use_syscall(&mut []) {
+        Ok(()) => {
+            RNG_STATE.store(STATE_USE_SYSCALL, Ordering::Release);
+            use_syscall(dest)
+        },
+        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);
+                    use_fd(dest)
+                },
+                Err(err) => {
+                    RNG_STATE.store(0, Ordering::Release);
+                    Err(err.into())
                 }
-                RngSource::Device(File::open("/dev/urandom")?)
-            };
-            Ok(s)
-        }, |f| {
-            match f {
-                RngSource::GetRandom => syscall_getrandom(dest),
-                RngSource::Device(f) => f.read_exact(dest),
-            }.map_err(From::from)
-        })
-    })
+            }
+        },
+        Err(err) => Err(err),
+    }
 }
 
-fn is_getrandom_available() -> bool {
-    use std::sync::{Once, ONCE_INIT};
-
-    static CHECKER: Once = ONCE_INIT;
-    static AVAILABLE: AtomicBool = AtomicBool::new(false);
+fn init_fd() -> io::Result<i32> {
+    File::open("/dev/random")?.read_exact(&mut [0u8; 1])?;
+    let f = File::open("/dev/urandom")?;
+    let fd = f.as_raw_fd();
+    mem::forget(f);
+    Ok(fd)
+}
 
-    CHECKER.call_once(|| {
-        let mut buf: [u8; 0] = [];
-        let available = match syscall_getrandom(&mut buf) {
-            Ok(()) => true,
-            Err(err) => err.raw_os_error() != Some(libc::ENOSYS),
-        };
-        AVAILABLE.store(available, Ordering::Relaxed);
-    });
+fn use_syscall(dest: &mut [u8]) -> Result<(), Error> {
+    let ret = unsafe {
+        libc::syscall(libc::SYS_getrandom, dest.as_mut_ptr(), dest.len(), 0)
+    };
+    if ret < 0 || (ret as usize) != dest.len() {
+        return Err(io::Error::last_os_error().into());
+    }
+    Ok(())
+}
 
-    AVAILABLE.load(Ordering::Relaxed)
+fn use_fd(dest: &mut [u8]) -> Result<(), Error> {
+    unsafe {
+        let fd = RNG_FD.load(Ordering::Acquire) as i32;
+        let mut f = File::from_raw_fd(fd);
+        f.read_exact(dest)?;
+        mem::forget(f);
+    }
+    Ok(())
 }
 
 #[inline(always)]