*: migrate from lazy_static! to std::sync::LazyLock

This was only stabilised in Rust 1.80.0, so this might cause issues when
building on older distributions (depending on when libpathrs starts
getting packaged).

Signed-off-by: Aleksa Sarai <[email protected]>

Author: cyphar

Cargo.toml

@@ -48,7 +48,6 @@ panic = "abort"
 
 [dependencies]
 bitflags = "^2"
-lazy_static = "^1"
 libc = "^0.2"
 memchr = "^2"
 rand = "^0.8"

src/capi/ret.rs

@@ -27,7 +27,7 @@ use std::{
     fs::File,
     mem::ManuallyDrop,
     os::unix::io::{FromRawFd, IntoRawFd, RawFd},
-    sync::Mutex,
+    sync::{LazyLock, Mutex},
 };
 
 use libc::c_int;
@@ -40,9 +40,8 @@ pub(super) trait IntoCReturn {
 }
 
 // TODO: Switch this to using a slab or similar structure, possibly using a less heavy-weight lock?
-lazy_static! {
-    static ref ERROR_MAP: Mutex<HashMap<CReturn, Error>> = Mutex::new(HashMap::new());
-}
+static ERROR_MAP: LazyLock<Mutex<HashMap<CReturn, Error>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
 
 fn store_error(err: Error) -> CReturn {
     let mut err_map = ERROR_MAP.lock().unwrap();

src/lib.rs

@@ -129,8 +129,6 @@
 
 #[macro_use]
 extern crate bitflags;
-#[macro_use]
-extern crate lazy_static;
 extern crate libc;
 #[macro_use]
 extern crate snafu;

src/procfs.rs

@@ -31,15 +31,14 @@ use std::{
     os::fd::AsRawFd,
     os::unix::fs::MetadataExt,
     path::{Path, PathBuf},
+    sync::LazyLock,
 };
 
 use snafu::{OptionExt, ResultExt};
 
-lazy_static! {
-    /// A `procfs` handle to which is used globally by libpathrs.
-    pub(crate) static ref PROCFS_HANDLE: ProcfsHandle =
-        ProcfsHandle::new().expect("should be able to get some /proc handle");
-}
+/// A `procfs` handle to which is used globally by libpathrs.
+pub(crate) static PROCFS_HANDLE: LazyLock<ProcfsHandle> =
+    LazyLock::new(|| ProcfsHandle::new().expect("should be able to get some /proc handle"));
 
 /// Indicate what base directory should be used when doing `/proc/...`
 /// operations with a [`ProcfsHandle`].

src/resolvers/mod.rs

@@ -20,7 +20,7 @@
 
 use crate::{error::Error, flags::ResolverFlags, syscalls, Handle};
 
-use std::{fs::File, path::Path};
+use std::{fs::File, path::Path, sync::LazyLock};
 
 /// `O_PATH`-based userspace resolver.
 pub mod opath;
@@ -51,13 +51,13 @@ pub enum ResolverBackend {
     //       hyper-concerned users.
 }
 
-lazy_static! {
-    static ref DEFAULT_RESOLVER_TYPE: ResolverBackend = if *syscalls::OPENAT2_IS_SUPPORTED {
+static DEFAULT_RESOLVER_TYPE: LazyLock<ResolverBackend> = LazyLock::new(|| {
+    if *syscalls::OPENAT2_IS_SUPPORTED {
         ResolverBackend::KernelOpenat2
     } else {
         ResolverBackend::EmulatedOpath
-    };
-}
+    }
+});
 
 impl Default for ResolverBackend {
     fn default() -> Self {

src/syscalls.rs

@@ -36,16 +36,12 @@ use std::{
     },
     path::{Path, PathBuf},
     ptr,
+    sync::LazyLock,
 };
 
 use libc::{c_int, c_uint, dev_t, mode_t, stat, statfs};
 use snafu::ResultExt;
 
-lazy_static! {
-    pub(crate) static ref OPENAT2_IS_SUPPORTED: bool =
-        openat2(libc::AT_FDCWD, ".", &Default::default()).is_ok();
-}
-
 /// Representation of a file descriptor and its associated path at a given point
 /// in time.
 ///
@@ -639,21 +635,19 @@ pub(crate) fn renameat<P1: AsRef<Path>, P2: AsRef<Path>>(
     }
 }
 
-lazy_static! {
-    pub(crate) static ref RENAME_FLAGS_SUPPORTED: bool = {
-        match renameat2(
-            libc::AT_FDCWD,
-            ".",
-            libc::AT_FDCWD,
-            ".",
-            libc::RENAME_EXCHANGE,
-        ) {
-            Ok(_) => true,
-            // We expect EBUSY, but just to be safe we only check for ENOSYS.
-            Err(err) => err.root_cause().raw_os_error() != Some(libc::ENOSYS),
-        }
-    };
-}
+pub(crate) static RENAME_FLAGS_SUPPORTED: LazyLock<bool> = LazyLock::new(|| {
+    match renameat2(
+        libc::AT_FDCWD,
+        ".",
+        libc::AT_FDCWD,
+        ".",
+        libc::RENAME_EXCHANGE,
+    ) {
+        Ok(_) => true,
+        // We expect EBUSY, but just to be safe we only check for ENOSYS.
+        Err(err) => err.root_cause().raw_os_error() != Some(libc::ENOSYS),
+    }
+});
 
 /// Wrapper for `renameat2(2)`.
 ///
@@ -781,6 +775,9 @@ pub(crate) fn statx<P: AsRef<Path>>(
     }
 }
 
+pub(crate) static OPENAT2_IS_SUPPORTED: LazyLock<bool> =
+    LazyLock::new(|| openat2(libc::AT_FDCWD, ".", &Default::default()).is_ok());
+
 /// Arguments for how `openat2` should open the target path.
 // TODO: Maybe switch to libc::open_how?
 #[repr(C)]