Add LazyBool for lock-free initialization

Author: josephlr

Cargo.toml

@@ -27,10 +27,6 @@ libc = "0.2.54"
 [target.'cfg(any(unix, target_os = "redox"))'.dependencies]
 lazy_static = "1.3.0"
 
-# For caching result of CPUID check for RDRAND
-[target.'cfg(target_os = "uefi")'.dependencies]
-lazy_static = { version = "1.3.0", features = ["spin_no_std"] }
-
 [target.wasm32-unknown-unknown.dependencies]
 wasm-bindgen = { version = "0.2.29", optional = true }
 stdweb = { version = "0.4.9", optional = true }

src/lib.rs

@@ -141,6 +141,8 @@ macro_rules! error {
 extern crate std;
 
 mod error;
+#[allow(dead_code)]
+mod util;
 pub use crate::error::Error;
 
 // System-specific implementations.

src/linux_android.rs

@@ -9,9 +9,9 @@
 //! Implementation for Linux / Android
 extern crate std;
 
+use crate::util::LazyBool;
 use crate::{use_file, Error};
 use core::num::NonZeroU32;
-use lazy_static::lazy_static;
 use std::io;
 
 fn syscall_getrandom(dest: &mut [u8], block: bool) -> Result<usize, io::Error> {
@@ -29,18 +29,15 @@ fn syscall_getrandom(dest: &mut [u8], block: bool) -> Result<usize, io::Error> {
 }
 
 pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    lazy_static! {
-        static ref HAS_GETRANDOM: bool = is_getrandom_available();
-    }
-    match *HAS_GETRANDOM {
-        true => {
-            let mut start = 0;
-            while start < dest.len() {
-                start += syscall_getrandom(&mut dest[start..], true)?;
-            }
-            Ok(())
+    static HAS_GETRANDOM: LazyBool = LazyBool::new();
+    if HAS_GETRANDOM.unsync_init(is_getrandom_available) {
+        let mut start = 0;
+        while start < dest.len() {
+            start += syscall_getrandom(&mut dest[start..], true)?;
         }
-        false => use_file::getrandom_inner(dest),
+        Ok(())
+    } else {
+        use_file::getrandom_inner(dest)
     }
 }
 

src/rdrand.rs

@@ -7,6 +7,7 @@
 // except according to those terms.
 
 //! Implementation for SGX using RDRAND instruction
+use crate::util::LazyBool;
 use crate::Error;
 use core::arch::x86_64::_rdrand64_step;
 use core::mem;
@@ -55,13 +56,10 @@ fn is_rdrand_supported() -> bool {
 #[cfg(not(target_feature = "rdrand"))]
 fn is_rdrand_supported() -> bool {
     use core::arch::x86_64::__cpuid;
-    use lazy_static::lazy_static;
     // SAFETY: All x86_64 CPUs support CPUID leaf 1
     const FLAG: u32 = 1 << 30;
-    lazy_static! {
-        static ref HAS_RDRAND: bool = unsafe { __cpuid(1).ecx & FLAG != 0 };
-    }
-    *HAS_RDRAND
+    static HAS_RDRAND: LazyBool = LazyBool::new();
+    HAS_RDRAND.unsync_init(|| unsafe { (__cpuid(1).ecx & FLAG) != 0 })
 }
 
 pub fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {

src/util.rs

@@ -0,0 +1,24 @@
+use core::sync::atomic::{AtomicBool, Ordering};
+
+#[derive(Debug)]
+pub struct LazyBool {
+    value: AtomicBool,
+    needs_init: AtomicBool,
+}
+
+impl LazyBool {
+    pub const fn new() -> Self {
+        LazyBool {
+            value: AtomicBool::new(false),
+            needs_init: AtomicBool::new(true),
+        }
+    }
+
+    pub fn unsync_init(&self, init: impl FnOnce() -> bool) -> bool {
+        if self.needs_init.load(Ordering::SeqCst) {
+            self.value.store(init(), Ordering::SeqCst);
+            self.needs_init.store(false, Ordering::SeqCst);
+        }
+        self.value.load(Ordering::SeqCst)
+    }
+}