refactor(fspy-shared): make the channel allocator-generic

channel(), Receiver, and sender() are now generic over an
allocator-api2 allocator instead of hardcoding the global allocator and
an internal pooled bump:

- channel() threads the caller's allocator through the shared-memory
  backing path and the ShmKeeper; the supervisor instantiates with
  Global.
- sender() takes the allocator for its transient shm-path decode from
  the caller, and the client constructors pass it through from the top
  of the call stack — the preload ctor and DllMain — so the choice of
  preload-safe memory lives where the attach begins, not inside
  library code.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: wan9chi

Cargo.lock

@@ -6,6 +6,7 @@ license.workspace = true
 publish = false
 
 [dependencies]
+allocator-api2 = { workspace = true, features = ["alloc"] }
 wincode = { workspace = true }
 bstr = { workspace = true, features = ["alloc", "std"] }
 bumpalo = { workspace = true }

crates/fspy/Cargo.toml

@@ -1,3 +1,4 @@
+use allocator_api2::alloc::Global;
 use fspy_shared::ipc::{
     PathAccess,
     channel::{FrameReader, Receiver},
@@ -37,7 +38,7 @@ pub struct ChannelAccesses {
     frames: FrameReader,
 }
 
-impl TryFrom<Receiver> for ChannelAccesses {
+impl TryFrom<Receiver<Global>> for ChannelAccesses {
     type Error = TrackingIncomplete;
 
     /// Closes the channel and takes every record it collected.
@@ -52,7 +53,7 @@ impl TryFrom<Receiver> for ChannelAccesses {
     /// [`TrackingIncomplete`] when a tracked process could not record
     /// something it went on to do. What did arrive is then a subset of
     /// what the run really touched, so none of it is handed back.
-    fn try_from(receiver: Receiver) -> Result<Self, TrackingIncomplete> {
+    fn try_from(receiver: Receiver<Global>) -> Result<Self, TrackingIncomplete> {
         Ok(Self { frames: receiver.close().map_err(|_| TrackingIncomplete)? })
     }
 }

crates/fspy/src/ipc.rs

@@ -80,7 +80,8 @@ impl SpyImpl {
 
         #[cfg(not(target_env = "musl"))]
         let (ipc_channel_conf, ipc_receiver) =
-            channel(crate::ipc::shm_capacity()).map_err(SpawnError::ChannelCreation)?;
+            channel(crate::ipc::shm_capacity(), allocator_api2::alloc::Global)
+                .map_err(SpawnError::ChannelCreation)?;
 
         let payload = Payload {
             #[cfg(not(target_env = "musl"))]

crates/fspy/src/unix/mod.rs

@@ -84,7 +84,8 @@ impl SpyImpl {
         command.creation_flags(CREATE_SUSPENDED);
 
         let (channel_conf, receiver) =
-            channel(crate::ipc::shm_capacity()).map_err(SpawnError::ChannelCreation)?;
+            channel(crate::ipc::shm_capacity(), allocator_api2::alloc::Global)
+                .map_err(SpawnError::ChannelCreation)?;
 
         let mut spawn_success = false;
         let spawn_success = &mut spawn_success;

crates/fspy/src/windows/mod.rs

@@ -10,6 +10,7 @@ pub mod raw_exec;
 
 use std::{ffi::OsStr, fmt::Debug, os::unix::ffi::OsStrExt as _, path::Path};
 
+use allocator_api2::alloc::Allocator;
 use convert::{ToAbsolutePath, ToAccessMode};
 use fspy_shared::ipc::{PathAccess, channel::Sender};
 use fspy_shared_unix::{
@@ -47,14 +48,17 @@ impl Client {
     /// Panics when the payload is missing, malformed, or cannot be decoded,
     /// and when the channel is there but cannot be attached to (see
     /// [`ChannelConf::sender`](fspy_shared::ipc::channel::ChannelConf::sender)).
-    pub fn from_env(envs: impl Iterator<Item = fspy_nostd::env::Entry>) -> Self {
+    pub fn from_env(
+        envs: impl Iterator<Item = fspy_nostd::env::Entry>,
+        allocator: impl Allocator,
+    ) -> Self {
         let encoded_payload = decode_payload_from_env(envs).unwrap();
 
         // `None` when the channel is already over, which happens when this
         // process starts after the root target exited. Nothing is said
         // about it: a preload library writing to the traced process's
         // stderr corrupts whatever that process is printing.
-        let ipc_sender = encoded_payload.payload.ipc_channel_conf.sender();
+        let ipc_sender = encoded_payload.payload.ipc_channel_conf.sender(allocator);
 
         Self { encoded_payload, ipc_sender }
     }

crates/fspy_client_unix/src/lib.rs

@@ -45,5 +45,5 @@ fn init_client() {
     // SAFETY: the ctor only reads the process environment while constructing
     // the client and does not retain borrowed environment views.
     let current = unsafe { fspy_nostd::env::current() }.unwrap();
-    CLIENT.set(Client::from_env(current.envs())).unwrap();
+    CLIENT.set(Client::from_env(current.envs(), fspy_nostd_alloc::pooled_bump())).unwrap();
 }

crates/fspy_preload_unix/src/client.rs

@@ -13,6 +13,8 @@ wincode = { workspace = true }
 constcat = { workspace = true }
 fspy_detours_sys = { workspace = true }
 fspy_nostd = { workspace = true }
+allocator-api2 = { workspace = true }
+fspy_nostd_alloc = { workspace = true }
 fspy_shared = { workspace = true }
 ntapi = { workspace = true }
 smallvec = { workspace = true }

crates/fspy_preload_windows/Cargo.toml

@@ -1,5 +1,6 @@
 use std::{cell::SyncUnsafeCell, ffi::CStr, mem::MaybeUninit};
 
+use allocator_api2::alloc::Allocator;
 use fspy_detours_sys::DetourCopyPayloadToProcess;
 use fspy_shared::{
     ipc::{PathAccess, channel::Sender},
@@ -13,14 +14,14 @@ pub struct Client<'a> {
 }
 
 impl<'a> Client<'a> {
-    pub fn from_payload_bytes(payload_bytes: &'a [u8]) -> Self {
+    pub fn from_payload_bytes(payload_bytes: &'a [u8], allocator: impl Allocator) -> Self {
         let payload: Payload<'a> = wincode::deserialize_exact(payload_bytes).unwrap();
 
         // `None` when the channel is already over, which happens when this
         // process starts after the root target exited. Nothing is said
         // about it: a detours DLL writing to the traced process's stderr
         // corrupts whatever that process is printing.
-        let ipc_sender = payload.channel_conf.sender();
+        let ipc_sender = payload.channel_conf.sender(allocator);
 
         Self { payload, ipc_sender }
     }

crates/fspy_preload_windows/src/windows/client.rs

@@ -45,7 +45,7 @@ fn dll_main(_hinstance: HINSTANCE, reason: u32) -> winsafe::SysResult<()> {
             let payload_bytes = unsafe {
                 slice::from_raw_parts::<'static, u8>(payload_ptr, payload_len.try_into().unwrap())
             };
-            let client = Client::from_payload_bytes(payload_bytes);
+            let client = Client::from_payload_bytes(payload_bytes, fspy_nostd_alloc::pooled_bump());
             // SAFETY: setting the global client during single-threaded DLL_PROCESS_ATTACH
             unsafe { set_global_client(client) };