Replace lazy_static with std::sync::LazyLock in fbcode/hermetic_infra

Summary: The `lazy_static` crate is deprecated in favor of a plain `static` containing `std::sync::LazyLock` or `std::sync::OnceLock`.

Reviewed By: diliop

Differential Revision: D109464793

fbshipit-source-id: 1fc685e8cb2cdbffd8a76a7f61eb1d7cc8392656

Author: David Tolnay

reverie-ptrace/Cargo.toml

@@ -17,7 +17,6 @@ close-err = "1.0.2"
 futures = { version = "0.3.31", features = ["async-await", "compat"] }
 goblin = { version = "0.10.7", features = ["elf32", "elf64", "endian_fd"] }
 iced-x86 = "1.21.0"
-lazy_static = "1.5"
 libc = "0.2.186"
 nix = { version = "0.30.1", features = ["dir", "event", "hostname", "inotify", "ioctl", "mman", "mount", "net", "poll", "ptrace", "reboot", "resource", "sched", "signal", "term", "time", "user", "zerocopy"] }
 num-traits = { version = "0.2.19", default-features = false }

reverie-ptrace/src/perf.rs

@@ -25,8 +25,8 @@
 use core::ptr::NonNull;
 #[allow(unused_imports)] // only used if we have an error
 use std::compile_error;
+use std::sync::LazyLock;
 
-use lazy_static::lazy_static;
 use nix::sys::signal::Signal;
 use nix::unistd::SysconfVar;
 use nix::unistd::sysconf;
@@ -40,9 +40,7 @@ use tracing::warn;
 use crate::validation::PmuValidationError;
 use crate::validation::check_for_pmu_bugs;
 
-lazy_static! {
-    static ref PMU_BUG: Result<(), PmuValidationError> = check_for_pmu_bugs();
-}
+static PMU_BUG: LazyLock<Result<(), PmuValidationError>> = LazyLock::new(check_for_pmu_bugs);
 
 // Not available in the libc crate
 const F_SETOWN_EX: libc::c_int = 15;
@@ -533,9 +531,7 @@ fn test_perf_pmu_support() -> bool {
     false
 }
 
-lazy_static! {
-    static ref IS_PERF_SUPPORTED: bool = test_perf_pmu_support();
-}
+static IS_PERF_SUPPORTED: LazyLock<bool> = LazyLock::new(test_perf_pmu_support);
 
 /// Returns true if the current system configuration supports use of perf for
 /// hardware events.

reverie-ptrace/src/vdso.rs

@@ -8,9 +8,9 @@
 
 //! Provides APIs to disable VDSOs at runtime.
 use std::collections::HashMap;
+use std::sync::LazyLock;
 
 use goblin::elf::Elf;
-use lazy_static::lazy_static;
 use nix::sys::mman::ProtFlags;
 use nix::unistd;
 use reverie::Error;
@@ -168,33 +168,31 @@ fn align_up(value: usize, alignment: usize) -> usize {
     (value + alignment - 1) & alignment.wrapping_neg()
 }
 
-lazy_static! {
-    static ref VDSO_PATCH_INFO: HashMap<&'static str, (u64, usize, &'static [u8])> = {
-        let info = vdso_get_symbols_info();
-        let mut res = HashMap::new();
-
-        for (k, v) in VDSO_SYMBOLS {
-            if let Some(&(base, size)) = info.get(*k) {
-                // NOTE: There is padding at the end of every VDSO entry to
-                // bring it up to a 16-byte size alignment. The dynamic symbol
-                // table doesn't report the aligned size, so we must do the same
-                // alignment here. For example, some VDSO entries might only be
-                // 5 bytes, but they have padding to align them up to 16 bytes.
-                let aligned_size = align_up(size, 16);
-                assert!(
-                    v.len() <= aligned_size,
-                    "vdso symbol {}'s real size is {} bytes, but trying to replace it with {} bytes",
-                    k,
-                    size,
-                    v.len()
-                );
-                res.insert(*k, (base, aligned_size, *v));
-            }
+static VDSO_PATCH_INFO: LazyLock<HashMap<&str, (u64, usize, &[u8])>> = LazyLock::new(|| {
+    let info = vdso_get_symbols_info();
+    let mut res = HashMap::new();
+
+    for (k, v) in VDSO_SYMBOLS {
+        if let Some(&(base, size)) = info.get(*k) {
+            // NOTE: There is padding at the end of every VDSO entry to
+            // bring it up to a 16-byte size alignment. The dynamic symbol
+            // table doesn't report the aligned size, so we must do the same
+            // alignment here. For example, some VDSO entries might only be
+            // 5 bytes, but they have padding to align them up to 16 bytes.
+            let aligned_size = align_up(size, 16);
+            assert!(
+                v.len() <= aligned_size,
+                "vdso symbol {}'s real size is {} bytes, but trying to replace it with {} bytes",
+                k,
+                size,
+                v.len()
+            );
+            res.insert(*k, (base, aligned_size, *v));
         }
+    }
 
-        res
-    };
-}
+    res
+});
 
 // get vdso symbols offset/size from current process
 // assuming vdso binary is the same for all processes

reverie/Cargo.toml

@@ -14,7 +14,6 @@ anyhow = "1.0.102"
 async-trait = "0.1.86"
 bitflags = { version = "2.11.1", features = ["serde", "std"], default-features = false }
 byteorder = "1.5"
-lazy_static = "1.5"
 libc = "0.2.186"
 linked-hash-map = { version = "0.5", features = ["serde_impl"] }
 memmap2 = "0.9.10"

reverie/src/backtrace/cache.rs

@@ -7,6 +7,7 @@
  */
 
 use std::sync::Arc;
+use std::sync::LazyLock;
 use std::sync::Mutex;
 use std::sync::MutexGuard;
 
@@ -22,9 +23,7 @@ use super::symbols::Symbols;
 /// symbols will be removed.
 const DEFAULT_MAX_CACHE_SIZE: usize = 1 << 30; // 1 GiB
 
-lazy_static::lazy_static! {
-    static ref CACHE: Mutex<DebugInfoCache> = Mutex::new(DebugInfoCache::new());
-}
+static CACHE: LazyLock<Mutex<DebugInfoCache>> = LazyLock::new(|| Mutex::new(DebugInfoCache::new()));
 
 /// An LRU cache of loaded symbols. This is shared by all processes since we
 /// only need to load symbols once for a particular inode. However, each process

safeptrace/Cargo.toml

@@ -11,7 +11,6 @@ license = "BSD-2-Clause"
 [dependencies]
 bitflags = { version = "2.11.1", features = ["serde", "std"], default-features = false }
 futures = { version = "0.3.31", features = ["async-await", "compat"] }
-lazy_static = "1.5"
 libc = "0.2.186"
 nix = { version = "0.30.1", features = ["dir", "event", "hostname", "inotify", "ioctl", "mman", "mount", "net", "poll", "ptrace", "reboot", "resource", "sched", "signal", "term", "time", "user", "zerocopy"] }
 parking_lot = { version = "0.12.1", features = ["arc_lock", "send_guard"] }

safeptrace/src/notifier.rs

@@ -68,6 +68,7 @@ use std::collections::hash_map::Entry;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
+use std::sync::LazyLock;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::Ordering;
 use std::task::Context;
@@ -77,7 +78,6 @@ use std::thread;
 use std::thread::JoinHandle;
 
 use futures::task::AtomicWaker;
-use lazy_static::lazy_static;
 use nix::sys::wait::WaitPidFlag;
 use nix::sys::wait::WaitStatus;
 use parking_lot::Mutex;
@@ -90,9 +90,7 @@ use super::Stopped;
 use super::Wait;
 use super::waitid;
 
-lazy_static! {
-    static ref NOTIFIER: Notifier = Notifier::new();
-}
+static NOTIFIER: LazyLock<Notifier> = LazyLock::new(Notifier::new);
 
 /// A place-holder status used to indicate that no status has been set.
 const INVALID_STATUS: i32 = -1;