Remove TLS by using sync::Once

Author: josephlr

src/lib.rs

@@ -128,24 +128,11 @@ extern crate log;
 #[allow(unused)]
 macro_rules! error { ($($x:tt)*) => () }
 
-// temp fix for stdweb
-#[cfg(target_arch = "wasm32")]
-extern crate std;
-
-#[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",
-    all(
-        target_arch = "wasm32", 
-        not(target_os = "wasi")
-    ),
-))]
+#[cfg(any(unix, target_os = "redox", target_arch = "wasm32"))]
+#[allow(unused)]
+mod once;
+#[cfg(any(unix, target_os = "redox"))]
+#[allow(unused)]
 mod utils;
 mod error;
 pub use crate::error::Error;

src/linux_android.rs

@@ -9,23 +9,16 @@
 //! Implementation for Linux / Android
 extern crate std;
 
-use crate::Error;
-use crate::utils::use_init;
-use std::{thread_local, io::{self, Read}, fs::File};
-use core::cell::RefCell;
+use crate::{once::Once, utils::use_file, Error};
 use core::num::NonZeroU32;
-use core::sync::atomic::{AtomicBool, Ordering};
-
-static RNG_INIT: AtomicBool = AtomicBool::new(false);
+use std::io;
 
 enum RngSource {
     GetRandom,
-    Device(File),
+    File,
 }
 
-thread_local!(
-    static RNG_SOURCE: RefCell<Option<RngSource>> = RefCell::new(None);
-);
+static RNG_SOURCE: Once<RngSource> = Once::new();
 
 fn syscall_getrandom(dest: &mut [u8]) -> Result<(), io::Error> {
     let ret = unsafe {
@@ -39,46 +32,20 @@ fn syscall_getrandom(dest: &mut [u8]) -> Result<(), io::Error> {
 }
 
 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)
-                }
-                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)
-        })
-    })
-}
-
-fn is_getrandom_available() -> bool {
-    use std::sync::{Once, ONCE_INIT};
-
-    static CHECKER: Once = ONCE_INIT;
-    static AVAILABLE: AtomicBool = AtomicBool::new(false);
-
-    CHECKER.call_once(|| {
+    let source = RNG_SOURCE.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);
+        if let Err(err) = syscall_getrandom(&mut buf) {
+            if err.raw_os_error() == Some(libc::ENOSYS) {
+                return RngSource::File;
+            }
+        }
+        RngSource::GetRandom
     });
 
-    AVAILABLE.load(Ordering::Relaxed)
+    match source {
+        RngSource::GetRandom => Ok(syscall_getrandom(dest)?),
+        RngSource::File => use_file("/dev/urandom", None, dest),
+    }
 }
 
 #[inline(always)]

src/once.rs

@@ -0,0 +1,52 @@
+// Copyright 2019 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.
+//
+// Based on code from the "spin" create (MIT licensed).
+extern crate std;
+
+use core::{cell::UnsafeCell, ptr};
+use std::sync;
+
+/// An std-based implementation of spin::Once.
+pub struct Once<T> {
+    once: sync::Once,
+    data: UnsafeCell<Option<T>>,
+}
+
+unsafe impl<T: Send + Sync> Sync for Once<T> {}
+unsafe impl<T: Send> Send for Once<T> {}
+
+impl<T> Once<T> {
+    /// Creates a new `Once` value.
+    pub const fn new() -> Self {
+        Self {
+            once: sync::Once::new(),
+            data: UnsafeCell::new(None),
+        }
+    }
+
+    /// Performs an initialization routine once and only once. The given closure
+    /// will be executed if this is the first time `call_once` has been called,
+    /// and otherwise the routine will *not* be invoked.
+    ///
+    /// This method will block the calling thread if another initialization
+    /// routine is currently running.
+    ///
+    /// When this function returns, it is guaranteed that some initialization
+    /// has run and completed (it may not be the closure specified). The
+    /// returned pointer will point to the result from the closure that was
+    /// run.
+    pub fn call_once<F>(&self, f: F) -> &T
+    where
+        F: FnOnce() -> T,
+    {
+        self.once
+            .call_once(|| unsafe { ptr::write(self.data.get(), Some(f())) });
+        unsafe { &*self.data.get() }.as_ref().unwrap()
+    }
+}

src/solaris_illumos.rs

@@ -19,11 +19,10 @@
 //! libc::dlsym.
 extern crate std;
 
-use crate::Error;
-use crate::utils::use_init;
-use std::{thread_local, io::{self, Read}, fs::File};
-use core::cell::RefCell;
+use crate::{once::Once, utils::use_file, Error};
+use core::mem;
 use core::num::NonZeroU32;
+use std::io;
 
 #[cfg(target_os = "illumos")]
 type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) -> libc::ssize_t;
@@ -32,12 +31,10 @@ type GetRandomFn = unsafe extern "C" fn(*mut u8, libc::size_t, libc::c_uint) ->
 
 enum RngSource {
     GetRandom(GetRandomFn),
-    Device(File),
+    File,
 }
 
-thread_local!(
-    static RNG_SOURCE: RefCell<Option<RngSource>> = RefCell::new(None);
-);
+static RNG_SOURCE: Once<RngSource> = Once::new();
 
 fn libc_getrandom(rand: GetRandomFn, dest: &mut [u8]) -> Result<(), Error> {
     let ret = unsafe { rand(dest.as_mut_ptr(), dest.len(), 0) as libc::ssize_t };
@@ -51,51 +48,28 @@ fn libc_getrandom(rand: GetRandomFn, dest: &mut [u8]) -> Result<(), Error> {
 }
 
 pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    // 256 bytes is the lowest common denominator across all the Solaris
-    // derived platforms for atomically obtaining random data.
-    RNG_SOURCE.with(|f| {
-        use_init(
-            f,
-            || {
-                let s = match fetch_getrandom() {
-                    Some(fptr) => RngSource::GetRandom(fptr),
-                    None => RngSource::Device(File::open("/dev/random")?),
-                };
-                Ok(s)
-            },
-            |f| {
-                match f {
-                    RngSource::GetRandom(rp) => {
-                        for chunk in dest.chunks_mut(256) {
-                            libc_getrandom(*rp, chunk)?
-                        }
-                    }
-                    RngSource::Device(randf) => {
-                        for chunk in dest.chunks_mut(256) {
-                            randf.read_exact(chunk)?
-                        }
-                    }
-                };
-                Ok(())
-            },
-        )
-    })
-}
-
-fn fetch_getrandom() -> Option<GetRandomFn> {
-    use std::mem;
-    use std::sync::atomic::{AtomicUsize, Ordering};
+    let source = RNG_SOURCE.call_once(|| {
+        let name = "getrandom\0";
+        let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr() as *const _) };
 
-    static FPTR: AtomicUsize = AtomicUsize::new(1);
+        if addr.is_null() {
+            RngSource::File
+        } else {
+            RngSource::GetRandom(unsafe { mem::transmute(addr) })
+        }
+    });
 
-    if FPTR.load(Ordering::SeqCst) == 1 {
-        let name = "getrandom\0";
-        let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr() as *const _) as usize };
-        FPTR.store(addr, Ordering::SeqCst);
+    // 256 bytes is the lowest common denominator across all the Solaris
+    // derived platforms for atomically obtaining random data.
+    match source {
+        RngSource::GetRandom(rp) => {
+            for chunk in dest.chunks_mut(256) {
+                libc_getrandom(*rp, chunk)?
+            }
+            Ok(())
+        }
+        RngSource::File => use_file("/dev/urandom", Some(256), dest),
     }
-
-    let ptr = FPTR.load(Ordering::SeqCst);
-    unsafe { mem::transmute::<usize, Option<GetRandomFn>>(ptr) }
 }
 
 #[inline(always)]

src/use_file.rs

@@ -6,17 +6,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Implementation for DragonFly / Haiku
+//! Implementations that just need to read from a file
 extern crate std;
 
-use crate::Error;
-use crate::utils::use_init;
-use std::{thread_local, io::Read, fs::File};
-use core::cell::RefCell;
+use crate::{utils::use_file, Error};
 use core::num::NonZeroU32;
 
-thread_local!(static RNG_FILE: RefCell<Option<File>> = RefCell::new(None));
-
 #[cfg(target_os = "redox")]
 const FILE_PATH: &str = "rand:";
 #[cfg(target_os = "netbsd")]
@@ -25,31 +20,12 @@ const FILE_PATH: &str = "/dev/urandom";
 const FILE_PATH: &str = "/dev/random";
 
 pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    RNG_FILE.with(|f| {
-        use_init(f, || init_file(), |f| use_file(f, dest))
-    })
-}
-
-fn use_file(f: &mut File, dest: &mut [u8]) -> Result<(), Error> {
+    // `Crypto.getRandomValues` documents `dest` should be at most 65536 bytes.
     if cfg!(target_os = "emscripten") {
-        // `Crypto.getRandomValues` documents `dest` should be at most 65536 bytes.
-        for chunk in dest.chunks_mut(65536) {
-            f.read_exact(chunk)?;
-        }
+        use_file(FILE_PATH, Some(65536), dest)
     } else {
-        f.read_exact(dest)?;
-    }
-    core::mem::forget(f);
-    Ok(())
-}
-
-fn init_file() -> Result<File, Error> {
-    if cfg!(target_os = "netbsd") {
-        // read one byte from "/dev/random" to ensure that OS RNG has initialized
-        File::open("/dev/random")?.read_exact(&mut [0u8; 1])?;
+        use_file(FILE_PATH, None, dest)
     }
-    let f = File::open(FILE_PATH)?;
-    Ok(f)
 }
 
 #[inline(always)]

src/utils.rs

@@ -5,26 +5,38 @@
 // <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.
-use crate::Error;
-use core::cell::RefCell;
-use core::ops::DerefMut;
 
-/// If `f` contains `Some(T)` call `use_f` using contents of `f` as an argument,
-/// otherwise initialize `f` value using `init_f`, store resulting value in `f`
-/// and call `use_f`.
-pub(crate) fn use_init<T, F, U>(f: &RefCell<Option<T>>, init_f: F, mut use_f: U)
-    -> Result<(), Error>
-    where F: FnOnce() -> Result<T, Error>, U: FnMut(&mut T) -> Result<(), Error>
-{
-    let mut f = f.borrow_mut();
-    let f: &mut Option<T> = f.deref_mut();
-    match f {
-        None => *f = Some(init_f()?),
-        _ => (),
-    }
+//! Helper function for reading random data from a file.
+extern crate std;
+
+use crate::{once::Once, Error};
+use std::{
+    fs::File,
+    io::Read,
+    os::unix::io::{FromRawFd, IntoRawFd, RawFd},
+};
+
+static RNG_FILE: Once<Result<RawFd, Error>> = Once::new();
+
+pub(crate) fn use_file(path: &str, chunk_len: Option<usize>, dest: &mut [u8]) -> Result<(), Error> {
+    let result = RNG_FILE.call_once(|| {
+        if cfg!(target_os = "netbsd") || cfg!(target_os = "linux") || cfg!(target_os = "android") {
+            // read one byte from "/dev/random" to ensure that OS RNG has initialized
+            File::open("/dev/random")?.read_exact(&mut [0u8; 1])?;
+        }
+        Ok(File::open(path)?.into_raw_fd())
+    });
+    let mut f = match result {
+        Ok(fd) => unsafe { File::from_raw_fd(*fd) },
+        Err(e) => return Err(*e),
+    };
 
-    match f {
-        Some(f) => use_f(f),
-        None => unreachable!(),
+    if let Some(chunk_len) = chunk_len {
+        for chunk in dest.chunks_mut(chunk_len) {
+            f.read_exact(chunk)?;
+        }
+    } else {
+        f.read_exact(dest)?;
     }
+    Ok(())
 }

src/wasi.rs

@@ -7,6 +7,8 @@
 // except according to those terms.
 
 //! Implementation for WASI
+extern crate std;
+
 use crate::Error;
 use core::num::NonZeroU32;
 use std::io;