Add cargo features to disable usage of file I/O and dlsym in std_detect

Author: gnzlbg

ci/run.sh

@@ -58,12 +58,6 @@ cargo_test() {
         fi
     fi
     cmd="$cmd ${subcmd} --target=$TARGET $1"
-    if [ "$NOSTD" = "1" ]
-    then
-        cmd="$cmd -p core_arch"
-    else
-        cmd="$cmd -p core_arch -p std_detect -p stdsimd_examples"
-    fi
     cmd="$cmd -- $2"
     # Un-commenting this disables the test output and shows only a summary:
     #if [ "$NORUN" != "1" ]
@@ -88,8 +82,25 @@ cargo_output() {
 }
 
 cargo_setup
-cargo_test
-cargo_test "--release"
+
+CORE_ARCH="--manifest-path=crates/core_arch/Cargo.toml"
+STD_DETECT="--manifest-path=crates/std_detect/Cargo.toml"
+STDSIMD_EXAMPLES="--manifest-path=examples/Cargo.toml"
+cargo_test "${CORE_ARCH}"
+cargo_test "${CORE_ARCH} --release"
+if [ "$NOSTD" != "1" ]; then
+    cargo_test "${STD_DETECT}"
+    cargo_test "${STD_DETECT} --release"
+
+    cargo_test "${STD_DETECT} --no-default-features"
+    cargo_test "${STD_DETECT} --no-default-features --features=std_detect_file_io"
+    cargo_test "${STD_DETECT} --no-default-features --features=std_detect_dlsym_getauxval"
+    cargo_test "${STD_DETECT} --no-default-features --features=std_detect_dlsym_getauxval,std_detect_file_io"
+
+    cargo_test "${STDSIMD_EXAMPLES}"
+    cargo_test "${STDSIMD_EXAMPLES} --release"
+fi
+
 cargo_output
 
 # Test targets compiled with extra features.

crates/std_detect/Cargo.toml

@@ -23,9 +23,14 @@ is-it-maintained-open-issues = { repository = "rust-lang-nursery/stdsimd" }
 maintenance = { status = "experimental" }
 
 [dependencies]
-libc = "0.2"
+libc = { version = "0.2", optional = true, default-features = false }
 cfg-if = "0.1"
 
 [dev-dependencies]
 auxv = "0.3.3"
-cupid = "0.6.0"
+cupid = "0.6.0"
+
+[features]
+default = [ "std_detect_dlsym_getauxval", "std_detect_file_io" ]
+std_detect_file_io = []
+std_detect_dlsym_getauxval = [ "libc" ]

crates/std_detect/README.md

@@ -24,6 +24,22 @@ run-time feature detection support than the one offered by Rust's standard
 library. We intend to make `std_detect` more flexible and configurable in this
 regard to better serve the needs of `#[no_std]` targets. 
 
+# Features
+
+* `std_detect_dlsym_getauxval` (enabled by default, requires `libc`): Enable to
+use `libc::dlsym` to query whether [`getauxval`] is linked into the binary. When
+this is not the case, this feature allows other fallback methods to perform
+run-time feature detection. When this feature is disabled, `std_detect` assumes
+that [`getauxval`] is linked to the binary. If that is not the case the behavior
+is undefined.
+
+* `std_detect_file_io` (enabled by default, requires `std`): Enable to perform run-time feature
+detection using file APIs (e.g. `/proc/cpuinfo`, etc.) if other more performant
+methods fail. This feature requires `libstd` as a dependency, preventing the
+crate from working on applications in which `std` is not available.
+
+[`getauxval`]: http://man7.org/linux/man-pages/man3/getauxval.3.html
+
 # Platform support
 
 * All `x86`/`x86_64` targets are supported on all platforms by querying the

crates/std_detect/src/detect/cache.rs

@@ -3,13 +3,13 @@
 
 #![allow(dead_code)] // not used on all platforms
 
-use core::sync::atomic::Ordering;
+use sync::atomic::Ordering;
 
 #[cfg(target_pointer_width = "64")]
-use core::sync::atomic::AtomicU64;
+use sync::atomic::AtomicU64;
 
 #[cfg(target_pointer_width = "32")]
-use core::sync::atomic::AtomicU32;
+use sync::atomic::AtomicU32;
 
 /// Sets the `bit` of `x`.
 #[inline]

crates/std_detect/src/detect/os/linux/auxvec.rs

@@ -1,10 +1,8 @@
 //! Parses ELF auxiliary vectors.
 #![cfg_attr(not(target_arch = "aarch64"), allow(dead_code))]
 
-extern crate std;
-use self::std::{prelude::v1::*, fs::File, io::Read};
-
-use core::mem;
+#[cfg(feature = "std_detect_file_io")]
+use ::{fs::File, io::Read};
 
 /// Key to access the CPU Hardware capabilities bitfield.
 pub(crate) const AT_HWCAP: usize = 16;
@@ -34,8 +32,12 @@ pub(crate) struct AuxVec {
 ///
 /// There is no perfect way of reading the auxiliary vector.
 ///
-/// - If the `getauxval` is dynamically linked to this binary, it will be used.
-/// - Otherwise, try to read `/proc/self/auxv`.
+/// - If the `std_detect_dlsym_getauxval` cargo feature is enabled, this will use
+/// `getauxval` if its linked to the binary, and otherwise proceed to a fallback implementation.
+/// When `std_detect_dlsym_getauxval` is disabled, this will assume that `getauxval` is
+/// linked to the binary - if that is not the case the behavior is undefined.
+/// - Otherwise, if the `std_detect_file_io` cargo feature is enabled, it will
+///   try to read `/proc/self/auxv`.
 /// - If that fails, this function returns an error.
 ///
 /// Note that run-time feature detection is not invoked for features that can
@@ -49,8 +51,42 @@ pub(crate) struct AuxVec {
 /// [auxvec_h]: https://github.com/torvalds/linux/blob/master/include/uapi/linux/auxvec.h
 /// [auxv_docs]: https://docs.rs/auxv/0.3.3/auxv/
 pub(crate) fn auxv() -> Result<AuxVec, ()> {
-    // Try to call a dynamically-linked getauxval function.
-    if let Ok(hwcap) = getauxval(AT_HWCAP) {
+    #[cfg(feature = "std_detect_dlsym_getauxval")] {
+        // Try to call a dynamically-linked getauxval function.
+        if let Ok(hwcap) = getauxval(AT_HWCAP) {
+            // Targets with only AT_HWCAP:
+            #[cfg(any(target_arch = "aarch64", target_arch = "mips",
+                      target_arch = "mips64"))]
+            {
+                if hwcap != 0 {
+                    return Ok(AuxVec { hwcap });
+                }
+            }
+
+            // Targets with AT_HWCAP and AT_HWCAP2:
+            #[cfg(any(target_arch = "arm", target_arch = "powerpc64"))]
+            {
+                if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
+                    if hwcap != 0 && hwcap2 != 0 {
+                        return Ok(AuxVec { hwcap, hwcap2 });
+                    }
+                }
+            }
+            drop(hwcap);
+        }
+        #[cfg(feature = "std_detect_file_io")] {
+            // If calling getauxval fails, try to read the auxiliary vector from
+            // its file:
+            auxv_from_file("/proc/self/auxv")
+        }
+        #[cfg(not(feature = "std_detect_file_io"))] {
+            Err(())
+        }
+    }
+
+    #[cfg(not(feature = "std_detect_dlsym_getauxval"))] {
+        let hwcap = unsafe { ffi_getauxval(AT_HWCAP) };
+
         // Targets with only AT_HWCAP:
         #[cfg(any(target_arch = "aarch64", target_arch = "mips",
                   target_arch = "mips64"))]
@@ -63,22 +99,18 @@ pub(crate) fn auxv() -> Result<AuxVec, ()> {
         // Targets with AT_HWCAP and AT_HWCAP2:
         #[cfg(any(target_arch = "arm", target_arch = "powerpc64"))]
         {
-            if let Ok(hwcap2) = getauxval(AT_HWCAP2) {
-                if hwcap != 0 && hwcap2 != 0 {
-                    return Ok(AuxVec { hwcap, hwcap2 });
-                }
+            let hwcap2 = unsafe { ffi_getauxval(AT_HWCAP2) };
+            if hwcap != 0 && hwcap2 != 0 {
+                return Ok(AuxVec { hwcap, hwcap2 });
             }
         }
-        drop(hwcap);
     }
-    // If calling getauxval fails, try to read the auxiliary vector from
-    // its file:
-    auxv_from_file("/proc/self/auxv")
 }
 
 /// Tries to read the `key` from the auxiliary vector by calling the
 /// dynamically-linked `getauxval` function. If the function is not linked,
 /// this function return `Err`.
+#[cfg(feature = "std_detect_dlsym_getauxval")]
 fn getauxval(key: usize) -> Result<usize, ()> {
     use libc;
     pub type F = unsafe extern "C" fn(usize) -> usize;
@@ -98,6 +130,7 @@ fn getauxval(key: usize) -> Result<usize, ()> {
 
 /// Tries to read the auxiliary vector from the `file`. If this fails, this
 /// function returns `Err`.
+#[cfg(feature = "std_detect_file_io")]
 fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
     let mut file = File::open(file).map_err(|_| ())?;
 
@@ -117,6 +150,7 @@ fn auxv_from_file(file: &str) -> Result<AuxVec, ()> {
 
 /// Tries to interpret the `buffer` as an auxiliary vector. If that fails, this
 /// function returns `Err`.
+#[cfg(feature = "std_detect_file_io")]
 fn auxv_from_buf(buf: &[usize; 64]) -> Result<AuxVec, ()> {
     // Targets with only AT_HWCAP:
     #[cfg(any(target_arch = "aarch64", target_arch = "mips",
@@ -157,6 +191,7 @@ mod tests {
 
     // Reads the Auxiliary Vector key from /proc/self/auxv
     // using the auxv crate.
+    #[cfg(feature = "std_detect_file_io")]
     fn auxv_crate_getprocfs(key: usize) -> Option<usize> {
         use self::auxv_crate::AuxvType;
         use self::auxv_crate::procfs::search_procfs_auxv;
@@ -210,6 +245,7 @@ mod tests {
         }
     }
 
+    #[cfg(feature = "std_detect_file_io")]
     cfg_if! {
         if #[cfg(target_arch = "arm")] {
             #[test]
@@ -244,6 +280,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg(feature = "std_detect_file_io")]
     fn auxv_dump_procfs() {
         if let Ok(auxvec) = auxv_from_file("/proc/self/auxv") {
             println!("{:?}", auxvec);

crates/std_detect/src/detect/os/linux/mod.rs

@@ -1,6 +1,8 @@
 //! Run-time feature detection on Linux
 
 mod auxvec;
+
+#[cfg(feature = "std_detect_file_io")]
 mod cpuinfo;
 
 cfg_if! {

crates/std_detect/src/detect/os/x86.rs

@@ -1,10 +1,11 @@
 //! x86 run-time feature detection is OS independent.
 
-use core::{prelude::v1::*, mem};
 #[cfg(target_arch = "x86")]
-use core::arch::x86::*;
+use arch::x86::*;
 #[cfg(target_arch = "x86_64")]
-use core::arch::x86_64::*;
+use arch::x86_64::*;
+
+use mem;
 
 use crate::detect::{Feature, cache, bit};
 

crates/std_detect/src/lib.rs

@@ -12,8 +12,7 @@
 //! * `powerpc64`: [`is_powerpc64_feature_detected`]
 
 #![unstable(feature = "stdsimd", issue = "27731")]
-#![feature(const_fn, integer_atomics, staged_api, stdsimd)]
-#![feature(doc_cfg, allow_internal_unstable)]
+#![feature(const_fn, staged_api, stdsimd, doc_cfg, allow_internal_unstable)]
 #![cfg_attr(feature = "cargo-clippy", allow(clippy::shadow_reuse))]
 #![cfg_attr(
     feature = "cargo-clippy",
@@ -23,15 +22,29 @@
 #![cfg_attr(all(target_os = "freebsd", target_arch = "aarch64"), feature(asm))]
 #![no_std]
 
-#[cfg(test)]
-#[macro_use(println)]
-extern crate std;
-
-extern crate libc;
-
 #[macro_use]
 extern crate cfg_if;
 
+cfg_if! {
+    if #[cfg(feature = "std_detect_file_io")] {
+        #[cfg_attr(test, macro_use(println))]
+        extern crate std;
+
+        #[allow(unused_imports)]
+        use std::{arch, fs, io, mem, sync};
+    } else {
+        #[cfg(test)]
+        #[macro_use(println)]
+        extern crate std;
+
+        #[allow(unused_imports)]
+        use core::{arch, mem, sync};
+    }
+}
+
+#[cfg(feature = "std_detect_dlsym_getauxval")]
+extern crate libc;
+
 #[doc(hidden)]
 #[unstable(feature = "stdsimd", issue = "27731")]
 pub mod detect;