*: 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]>

Cargo.toml

@@ -48,9 +48,6 @@ lto = true
 [dependencies]
 bitflags = "^2"
 itertools = "^0.13"
-# MSRV(1.70): Use OnceLock.
-# MSRV(1.80): Use LazyLock.
-lazy_static = "^1"
 libc = "^0.2"
 memchr = "^2"
 # MSRV(1.65): Update to >=0.4.1 which uses let_else. 0.4.0 was broken.

src/capi/error.rs

@@ -27,19 +27,15 @@ use std::{
  error::Error as StdError,
  ffi::CString,
  ptr,
- sync::Mutex,
+ sync::{LazyLock, Mutex},
 };
 
 use libc::{c_char, c_int};
 use rand::{self, Rng};
 
-// TODO: Switch this to using a slab or similar structure, possibly using a less
-// heavy-weight lock? Maybe sharded-slab?
-// MSRV(1.70): Use OnceLock.
-// MSRV(1.80): Use LazyLock.
-lazy_static! {
- static ref ERROR_MAP: Mutex<HashMap<CReturn, Error>> = Mutex::new(HashMap::new());
-}
+// TODO: Switch this to using a slab or similar structure, possibly using a less heavy-weight lock?
+static ERROR_MAP: LazyLock<Mutex<HashMap<CReturn, Error>>> =
+ LazyLock::new(|| Mutex::new(HashMap::new()));
 
 pub(crate) fn store_error(err: Error) -> CReturn {
  let mut err_map = ERROR_MAP.lock().unwrap();

src/lib.rs

@@ -153,8 +153,6 @@
 
 #[macro_use]
 extern crate bitflags;
-#[macro_use]
-extern crate lazy_static;
 extern crate libc;
 
 // `Handle` implementation.

src/procfs.rs

@@ -34,19 +34,12 @@ use std::{
  io::Error as IOError,
  os::unix::io::{AsFd, BorrowedFd, OwnedFd},
  path::{Path, PathBuf},
+ sync::LazyLock,
 };
 
-// MSRV(1.70): Use OnceLock.
-// MSRV(1.80): Use LazyLock.
-lazy_static! {
- /// A lazy-allocated `procfs` handle which is used globally by libpathrs.
- ///
- /// As creating `procfs` handles can be somewhat expensive, library users
- /// are recommended to make use of this handle for `procfs` operations if
- /// possible.
- pub static ref GLOBAL_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 GLOBAL_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

@@ -31,6 +31,7 @@ use std::{
  os::unix::io::{AsFd, OwnedFd},
  path::{Path, PathBuf},
  rc::Rc,
+ sync::LazyLock,
 };
 
 /// `O_PATH`-based userspace resolver.
@@ -63,15 +64,13 @@ pub(crate) enum ResolverBackend {
  // hyper-concerned users.
 }
 
-// MSRV(1.70): Use OnceLock.
-// MSRV(1.80): Use LazyLock.
-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/resolvers/opath/impl.rs

@@ -58,6 +58,7 @@ use std::{
  },
  path::{Path, PathBuf},
  rc::Rc,
+ sync::LazyLock,
 };
 
 use itertools::Itertools;
@@ -130,17 +131,14 @@ fn check_current<RootFd: AsFd, Fd: AsFd, P: AsRef<Path>>(
  Ok(())
 }
 
-// MSRV(1.70): Use OnceLock.
-// MSRV(1.80): Use LazyLock.
-lazy_static! {
- /// Cached copy of `fs.protected_symlinks` sysctl.
- // TODO: In theory this value could change during the lifetime of the
- // program, but there's no nice way of detecting that, and the overhead of
- // checking this for every symlink lookup is more likely to be an issue.
- static ref PROTECTED_SYMLINKS_SYSCTL: u32 =
- utils::sysctl_read_parse(&GLOBAL_PROCFS_HANDLE, "fs.protected_symlinks")
- .expect("should be able to parse fs.protected_symlinks");
-}
+/// Cached copy of `fs.protected_symlinks` sysctl.
+// TODO: In theory this value could change during the lifetime of the
+// program, but there's no nice way of detecting that, and the overhead of
+// checking this for every symlink lookup is more likely to be an issue.
+static PROTECTED_SYMLINKS_SYSCTL: LazyLock<u32> = LazyLock::new(|| {
+ utils::sysctl_read_parse(&GLOBAL_PROCFS_HANDLE, "fs.protected_symlinks")
+ .expect("should be able to parse fs.protected_symlinks")
+});
 
 /// Verify that we should follow the symlink as per `fs.protected_symlinks`.
 ///

src/syscalls.rs

@@ -35,6 +35,7 @@ use std::{
  },
  path::{Path, PathBuf},
  ptr,
+ sync::LazyLock,
 };
 
 use libc::{c_int, c_uint, dev_t, mode_t, stat, statfs};
@@ -52,13 +53,6 @@ pub(crate) const AT_FDCWD: BorrowedFd<'static> = unsafe { BorrowedFd::borrow_raw
 #[cfg(test)]
 pub(crate) const BADFD: BorrowedFd<'static> = unsafe { BorrowedFd::borrow_raw(-libc::EBADF) };
 
-// MSRV(1.70): Use OnceLock.
-// MSRV(1.80): Use LazyLock.
-lazy_static! {
- pub(crate) static ref OPENAT2_IS_SUPPORTED: bool =
- openat2(AT_FDCWD, ".", &Default::default()).is_ok();
-}
-
 /// Representation of a file descriptor and its associated path at a given point
 /// in time.
 ///
@@ -561,23 +555,13 @@ pub(crate) fn renameat<Fd1: AsFd, P1: AsRef<Path>, Fd2: AsFd, P2: AsRef<Path>>(
  }
 }
 
-// MSRV(1.70): Use OnceLock.
-// MSRV(1.80): Use LazyLock.
-lazy_static! {
- pub(crate) static ref RENAME_FLAGS_SUPPORTED: bool = {
- match renameat2(
- AT_FDCWD,
- ".",
- 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(AT_FDCWD, ".", 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)`.
 ///
@@ -717,6 +701,9 @@ pub(crate) fn statx<Fd: AsFd, P: AsRef<Path>>(
  }
 }
 
+pub(crate) static OPENAT2_IS_SUPPORTED: LazyLock<bool> =
+ LazyLock::new(|| openat2(AT_FDCWD, ".", &Default::default()).is_ok());
+
 /// Arguments for how `openat2` should open the target path.
 // TODO: Maybe switch to libc::open_how?
 #[repr(C)]