diff --git a/Cargo.lock b/Cargo.lock
index 25a09b95..f9a40153 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1681,10 +1681,19 @@ version = "0.0.0"
 dependencies = [
  "libc",
  "log",
+ "process-reader",
  "serde",
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "process-reader"
+version = "0.0.0"
+dependencies = [
+ "libc",
+ "serde",
+]
+
 [[package]]
 name = "procfs-core"
 version = "0.17.0"
diff --git a/Cargo.toml b/Cargo.toml
index 8a1e594f..96f871c9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "3"
 members = [
+    "crates/process-reader",
     "crates/linux/process-backend",
 ]
 
@@ -54,6 +55,7 @@ byteorder = "1.4"
 error-graph = { version = "0.1.1", features = ["serde"] }
 failspot = "0.2.0"
 process-backend = { path = "crates/linux/process-backend", features = ["testing"] }
+
 # Used for parsing procfs info.
 # default-features is disabled since it pulls in chrono
 procfs-core = { version = "0.18", default-features = false, features = ["serde1"] }
diff --git a/crates/linux/process-backend/Cargo.toml b/crates/linux/process-backend/Cargo.toml
index ba920c99..ebc43e8f 100644
--- a/crates/linux/process-backend/Cargo.toml
+++ b/crates/linux/process-backend/Cargo.toml
@@ -7,9 +7,10 @@ edition.workspace = true
 rust-version.workspace = true
 license.workspace = true
 
-[dependencies]
+[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
 libc.workspace = true
 log.workspace = true
+process-reader = { path = "../../process-reader", features = ["serde"] }
 serde.workspace = true
 thiserror.workspace = true
 
diff --git a/crates/linux/process-backend/src/local/error.rs b/crates/linux/process-backend/src/local/error.rs
index c01c682b..79feefc3 100644
--- a/crates/linux/process-backend/src/local/error.rs
+++ b/crates/linux/process-backend/src/local/error.rs
@@ -48,4 +48,6 @@ pub enum Error {
     ProcessVmReadvFailed(c_int),
     #[error("failed to peek at process data: {0}")]
     PtracePeekDataFailed(c_int),
+    #[error("ProcessReader returned an error")]
+    ProcessReader(#[source] process_reader::ReadError),
 }
diff --git a/crates/linux/process-backend/src/local/mod.rs b/crates/linux/process-backend/src/local/mod.rs
index e594283f..c8c7de06 100644
--- a/crates/linux/process-backend/src/local/mod.rs
+++ b/crates/linux/process-backend/src/local/mod.rs
@@ -1,15 +1,13 @@
-use {
-    crate::regs::*,
-    core::{
-        cell::RefCell,
-        ffi::{CStr, c_int, c_long, c_void},
-        mem, ptr,
-    },
-    libc::pid_t,
-    syscall_invoker::SyscallInvoker,
+use crate::regs::*;
+use core::{
+    cell::RefCell,
+    ffi::{CStr, c_int, c_long, c_void},
+    mem, ptr,
 };
+use libc::pid_t;
+use syscall_invoker::SyscallInvoker;
 
-pub use {error::Error, module_reader::MappedModuleMemoryReader};
+pub use self::{error::Error, module_reader::MappedModuleMemoryReader};
 
 mod error;
 mod module_reader;
@@ -34,6 +32,9 @@ impl Backend {
             syscall_invoker: Default::default(),
         }
     }
+    pub fn process_reader(&self) -> ProcessReader {
+        ProcessReader(process_reader::ProcessReader::new(self.pid))
+    }
     pub fn stop_process(&self) -> Result<(), Error> {
         self.standard_syscall(|| unsafe { libc::kill(self.pid, libc::SIGSTOP) })
             .map_err(Error::SigStopFailed)?;
@@ -138,50 +139,6 @@ impl Backend {
         Ok(bytes_read)
     }
 
-    pub fn read_process_io_vec(&self, buf: &mut [u8], offset: usize) -> Result<usize, Error> {
-        let mut local_iov = [libc::iovec {
-            iov_base: buf.as_mut_ptr().cast(),
-            iov_len: buf.len(),
-        }];
-
-        let mut remote_iov = [libc::iovec {
-            iov_base: offset as *mut _,
-            iov_len: buf.len(),
-        }];
-
-        let bytes_read = self
-            .standard_syscall(|| unsafe {
-                libc::process_vm_readv(
-                    self.pid,
-                    local_iov.as_mut_ptr(),
-                    local_iov.len().try_into().unwrap(),
-                    remote_iov.as_mut_ptr(),
-                    remote_iov.len().try_into().unwrap(),
-                    0,
-                )
-            })
-            .map_err(Error::ProcessVmReadvFailed)?;
-
-        Ok(usize::try_from(bytes_read).unwrap())
-    }
-
-    pub fn ptrace_peekdata(&self, offset: usize) -> Result<[u8; mem::size_of::<c_long>()], Error> {
-        self.special_syscall(|| unsafe {
-            set_errno(0);
-            let rv = ptrace(
-                libc::PTRACE_PEEKDATA,
-                self.pid,
-                offset as *mut _,
-                ptr::null_mut(),
-            );
-            if rv == -1 && errno() != 0 {
-                return Err(());
-            }
-            Ok(rv.to_ne_bytes())
-        })
-        .map_err(Error::PtracePeekDataFailed)
-    }
-
     pub fn get_gen_regs(&self, tid: libc::pid_t) -> Result<GenRegs, Error> {
         self.getregset(tid).or_else(|_| self.getregs(tid))
     }
@@ -218,6 +175,20 @@ impl Backend {
         .map_err(Error::PtracePeekUserFailed)
     }
 
+    pub fn process_reader_for_virtual_mem(&self) -> ProcessReader {
+        ProcessReader(process_reader::ProcessReader::for_virtual_mem(self.pid))
+    }
+
+    pub fn process_reader_for_file(&self) -> Result<ProcessReader, Error> {
+        process_reader::ProcessReader::for_file(self.pid)
+            .map(ProcessReader)
+            .map_err(Error::ProcessReader)
+    }
+
+    pub fn process_reader_for_ptrace(&self) -> ProcessReader {
+        ProcessReader(process_reader::ProcessReader::for_ptrace(self.pid))
+    }
+
     fn open_file(&self, path: &CStr) -> Result<OwnedFd, Error> {
         self.standard_syscall(|| unsafe {
             libc::open(path.as_ptr(), libc::O_RDONLY | libc::O_CLOEXEC, 0)
@@ -321,7 +292,7 @@ impl Backend {
         Ok(())
     }
 
-    pub fn standard_syscall<T, F>(&self, f: F) -> Result<T, c_int>
+    fn standard_syscall<T, F>(&self, f: F) -> Result<T, c_int>
     where
         F: FnOnce() -> T,
         T: From<i8> + core::cmp::PartialEq,
@@ -329,7 +300,7 @@ impl Backend {
         self.syscall_invoker.borrow_mut().invoke_standard(f)
     }
 
-    pub fn special_syscall<T, F>(&self, f: F) -> Result<T, c_int>
+    fn special_syscall<T, F>(&self, f: F) -> Result<T, c_int>
     where
         F: FnOnce() -> Result<T, ()>,
     {
@@ -420,6 +391,15 @@ impl Drop for DirReader {
     }
 }
 
+#[derive(Debug)]
+pub struct ProcessReader(process_reader::ProcessReader);
+
+impl ProcessReader {
+    pub fn read_at(&self, address: usize, buf: &mut [u8]) -> Result<usize, Error> {
+        self.0.read_at(address, buf).map_err(Error::ProcessReader)
+    }
+}
+
 #[derive(Debug)]
 struct OwnedFd(c_int);
 
diff --git a/crates/process-reader/Cargo.toml b/crates/process-reader/Cargo.toml
new file mode 100644
index 00000000..9ca990a7
--- /dev/null
+++ b/crates/process-reader/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "process-reader"
+version = "0.0.0"
+edition = "2024"
+rust-version = "1.88.0"
+license = "MIT"
+readme = "README.md"
+
+[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
+libc = { version = "0.2.186", default-features = false }
+serde = { version = "1.0.228", default-features = false, features=["derive"], optional = true }
+
+[features]
+serde = ["dep:serde"]
\ No newline at end of file
diff --git a/crates/process-reader/README.md b/crates/process-reader/README.md
new file mode 100644
index 00000000..9909705c
--- /dev/null
+++ b/crates/process-reader/README.md
@@ -0,0 +1,130 @@
+# process-reader
+
+`process-reader` is a small `no_std` Rust crate for reading raw bytes from another Linux or Android process.
+
+It is designed for crash-reporting and minidump-writing code that needs to inspect process memory without depending on `std`. The crate copies bytes into a caller-provided buffer; it does not interpret the memory it reads.
+
+## Platform support
+
+This crate supports Linux and Android only. Other operating systems fail at compile time.
+
+The intended Android targets are contemporary Android systems. Very old Android releases are not part of the supported configuration.
+
+## Reading memory
+
+The main type is `ProcessReader`:
+
+```rust
+use process_reader::ProcessReader;
+
+fn read_some_memory(
+    pid: libc::pid_t,
+    address: usize,
+) -> Result<usize, process_reader::ReadError> {
+    let reader = ProcessReader::new(pid);
+
+    let mut bytes = [0u8; 16];
+    let bytes_read = reader.read_at(address, &mut bytes)?;
+
+    // Only this prefix was read by the call. It may be shorter than the buffer.
+    let _bytes = &bytes[..bytes_read];
+
+    Ok(bytes_read)
+}
+```
+
+`read_at(address, buf)` attempts to read bytes from `address` in the target process and returns the number of bytes copied. The returned length is in the range `0..=buf.len()`. The address is a virtual address in the target process, not in the calling process.
+
+A successful read may be shorter than `buf.len()`. Short successful reads are returned as `Ok(n)`, not as errors, so callers should only interpret `buf[..n]` as bytes read by the call.
+
+Passing an empty buffer succeeds immediately, returns `Ok(0)`, and does not perform a system call.
+
+## Strategies
+
+`ProcessReader` supports three Linux/Android process-memory mechanisms:
+
+| Constructor | Strategy |
+| --- | --- |
+| `ProcessReader::new(pid)` | Automatically choose a strategy on the first non-empty read request |
+| `ProcessReader::for_virtual_mem(pid)` | Use only `process_vm_readv(2)` |
+| `ProcessReader::for_file(pid)` | Use only `/proc/<pid>/mem` |
+| `ProcessReader::for_ptrace(pid)` | Use only `ptrace(PTRACE_PEEKDATA)` |
+
+`ProcessReader::new(pid)` tries strategies in this order:
+
+1. `process_vm_readv(2)`
+2. `/proc/<pid>/mem`
+3. `ptrace(PTRACE_PEEKDATA)`
+
+The first strategy that returns `Ok(_)` for a non-empty read request is cached by that reader. A successful read can be shorter than the requested buffer; a short successful read still selects the strategy. Later reads use the cached strategy directly and do not fall back to another strategy if the cached strategy fails for a different address.
+
+To force a specific mechanism, use one of the `for_*` constructors.
+
+### Strategy-specific read lengths
+
+The public API allows any strategy to return a short successful read. The current implementation has these strategy-specific behaviors:
+
+- `process_vm_readv(2)` returns the byte count reported by `process_vm_readv`, which may be smaller than the requested buffer.
+- `/proc/<pid>/mem` attempts to fill the whole buffer. On success it returns `Ok(buf.len())`; if it cannot fill the buffer, it returns an error.
+- `ptrace(PTRACE_PEEKDATA)` attempts to fill the whole buffer. On success it returns `Ok(buf.len())`; if it cannot fill the buffer, it returns an error.
+
+## PID invariant
+
+All constructors require a non-negative process ID. Passing `pid < 0` is considered a caller logic error and will panic.
+
+## Ptrace behavior
+
+`ProcessReader::for_ptrace(pid)` only performs `PTRACE_PEEKDATA` reads.
+
+It does not attach to the target, seize it, wait for it to stop, resume it, or detach from it. The caller must arrange any required ptrace relationship and target stopped state before reading.
+
+The requested address does not need to be word-aligned. The implementation performs aligned word reads internally and copies out the requested byte range.
+
+## Errors
+
+All read failures use `ReadError`.
+
+Short successful reads are not errors. They are returned as `Ok(n)` from `read_at`, where `n` is the number of bytes copied.
+
+When a `ReadError` represents one failed strategy, `ReadError::source()` returns that strategy's lower-level error.
+
+For a reader created with `ProcessReader::new(pid)`, the first read can fail because every strategy failed. That is an aggregate failure rather than a single error chain, so `ReadError::source()` returns `None`. Use the strategy-specific accessors to inspect the individual failures:
+
+```rust
+fn inspect_error(error: &process_reader::ReadError) {
+    if let Some(error) = error.virtual_mem_error() {
+        let _ = error;
+    }
+
+    if let Some(error) = error.file_error() {
+        let _ = error;
+    }
+
+    if let Some(error) = error.ptrace_error() {
+        let _ = error;
+    }
+}
+```
+
+The destination buffer may be partially overwritten when a read fails. The error does not report how many bytes were copied before the failure, so callers should not rely on the contents of the buffer after an error.
+
+The crate does not provide snapshot consistency. If the target process mutates memory while it is being read, the caller may observe a mixture of old and new bytes.
+
+## `no_std`
+
+The crate is `#![no_std]`. It depends on `libc` with default features disabled.
+
+## Optional features
+
+### `serde`
+
+Enables `Serialize` and `Deserialize` implementations for `ReadError`.
+
+```toml
+[dependencies]
+process-reader = { version = "0.0.0", features = ["serde"] }
+```
+
+## License
+
+MIT
diff --git a/crates/process-reader/src/lib.rs b/crates/process-reader/src/lib.rs
new file mode 100644
index 00000000..d40119df
--- /dev/null
+++ b/crates/process-reader/src/lib.rs
@@ -0,0 +1,6 @@
+#![no_std]
+
+pub use platform::*;
+
+#[cfg_attr(any(target_os = "linux", target_os = "android"), path = "linux/mod.rs")]
+mod platform;
diff --git a/crates/process-reader/src/linux/error.rs b/crates/process-reader/src/linux/error.rs
new file mode 100644
index 00000000..fd721185
--- /dev/null
+++ b/crates/process-reader/src/linux/error.rs
@@ -0,0 +1,285 @@
+use core::{
+    error::Error as StdError,
+    ffi::c_int,
+    fmt::{Display, Formatter, Result as FmtResult},
+};
+
+/// An error returned while reading memory from a target process.
+///
+/// `ReadError` is intentionally a small public wrapper around private strategy
+/// errors. Its [`Display`] implementation describes the high-level failure. Its
+/// [`core::error::Error::source`] implementation returns a lower-level source
+/// when there is exactly one failed strategy, including failures from forced
+/// strategies and failures from a strategy selected by an automatic reader.
+///
+/// Short successful reads are not represented by `ReadError`; they are returned
+/// from [`crate::ProcessReader::read_at`] as `Ok(n)` where `n` is smaller than
+/// the requested buffer length.
+///
+/// When [`crate::ProcessReader::new`] tries every strategy and all of them fail,
+/// there is no single source error. In that case
+/// [`core::error::Error::source`] returns `None`, and callers can inspect each
+/// branch with
+/// [`ReadError::virtual_mem_error`], [`ReadError::file_error`], and
+/// [`ReadError::ptrace_error`].
+///
+/// If the `serde` feature is enabled, this type implements `Serialize` and
+/// `Deserialize`.
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct ReadError(pub(crate) ReadErrorInner);
+
+impl ReadError {
+    /// Returns the error from the `process_vm_readv(2)` strategy, if present.
+    ///
+    /// This returns `Some` when a reader forced to or cached on
+    /// [`crate::ProcessReader::for_virtual_mem`] fails, and when automatic
+    /// strategy selection fails after attempting `process_vm_readv`.
+    ///
+    /// It returns `None` when the error does not contain a `process_vm_readv`
+    /// failure.
+    pub fn virtual_mem_error(&self) -> Option<&(dyn StdError + 'static)> {
+        match &self.0 {
+            ReadErrorInner::AllStrategies { vmem_err, .. } => Some(vmem_err),
+            ReadErrorInner::VirtualMemStrategy(e) => Some(e),
+            _ => None,
+        }
+    }
+
+    /// Returns the error from the `/proc/<pid>/mem` strategy, if present.
+    ///
+    /// This returns `Some` when a reader forced to or cached on
+    /// [`crate::ProcessReader::for_file`] fails, and when automatic strategy
+    /// selection fails after attempting to use `/proc/<pid>/mem`.
+    ///
+    /// It returns `None` when the error does not contain a `/proc/<pid>/mem`
+    /// failure.
+    pub fn file_error(&self) -> Option<&(dyn StdError + 'static)> {
+        match &self.0 {
+            ReadErrorInner::AllStrategies { file_err, .. } => Some(file_err),
+            ReadErrorInner::FileStrategy(e) => Some(e),
+            _ => None,
+        }
+    }
+
+    /// Returns the error from the `ptrace(PTRACE_PEEKDATA)` strategy, if present.
+    ///
+    /// This returns `Some` when a reader forced to or cached on
+    /// [`crate::ProcessReader::for_ptrace`] fails, and when automatic strategy
+    /// selection fails after attempting `ptrace(PTRACE_PEEKDATA)`.
+    ///
+    /// It returns `None` when the error does not contain a ptrace failure.
+    pub fn ptrace_error(&self) -> Option<&(dyn StdError + 'static)> {
+        match &self.0 {
+            ReadErrorInner::AllStrategies { ptrace_err, .. } => Some(ptrace_err),
+            ReadErrorInner::PtraceStrategy(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
+impl Display for ReadError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        use ReadErrorInner as E;
+        match &self.0 {
+            E::AllStrategies { .. } => write!(f, "all process reading strategies failed"),
+            E::VirtualMemStrategy(_) => write!(f, "virtual memory strategy failed"),
+            E::FileStrategy(_) => write!(f, "file strategy failed"),
+            E::PtraceStrategy(_) => write!(f, "ptrace strategy failed"),
+        }
+    }
+}
+
+impl StdError for ReadError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        use ReadErrorInner as E;
+        match &self.0 {
+            E::AllStrategies { .. } => None,
+            E::VirtualMemStrategy(e) => Some(e),
+            E::FileStrategy(e) => Some(e),
+            E::PtraceStrategy(e) => Some(e),
+        }
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) enum ReadErrorInner {
+    AllStrategies {
+        vmem_err: ProcessVmReadvFailed,
+        file_err: FileStrategyError,
+        ptrace_err: PtraceError,
+    },
+    VirtualMemStrategy(ProcessVmReadvFailed),
+    FileStrategy(FileStrategyError),
+    PtraceStrategy(PtraceError),
+}
+
+/// Error returned by [`ProcessReader::read_exact_at`].
+///
+/// [`ProcessReader::read_exact_at`] is built on top of
+/// [`ProcessReader::read_at`]. It repeatedly performs partial reads until the
+/// caller's buffer is full. This error reports why that exact read could not be
+/// completed.
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub enum ReadExactError {
+    /// An underlying call to [`ProcessReader::read_at`] failed before the buffer
+    /// was completely filled.
+    ///
+    /// The wrapped [`ReadError`] describes the strategy that failed, or the set
+    /// of strategies that failed if automatic strategy selection had not yet
+    /// chosen a strategy.
+    Read(ReadError),
+    /// The reader stopped making progress before the buffer was completely
+    /// filled.
+    ///
+    /// This occurs when [`ProcessReader::read_at`] returns `Ok(0)` while
+    /// `read_exact_at` still has bytes left to read.
+    UnexpectedEof,
+}
+
+impl Display for ReadExactError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        match self {
+            Self::Read(_) => write!(f, "an error occurred before filling entire buffer"),
+            Self::UnexpectedEof => write!(f, "unexpected end-of-file before filling entire buffer"),
+        }
+    }
+}
+
+impl StdError for ReadExactError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            Self::Read(e) => Some(e),
+            Self::UnexpectedEof => None,
+        }
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) struct ProcessVmReadvFailed(pub(crate) c_int);
+
+impl Display for ProcessVmReadvFailed {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        write!(f, "process_vm_readv() returned an error code: {}", self.0)
+    }
+}
+
+impl StdError for ProcessVmReadvFailed {}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) enum FileStrategyError {
+    Open(OpenFailed),
+    Read(ReadExactAtError),
+}
+
+impl Display for FileStrategyError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        match self {
+            Self::Open(_) => write!(f, "failed to open /proc/<pid>/mem file"),
+            Self::Read(_) => write!(f, "failed to read /proc/<pid>/mem file"),
+        }
+    }
+}
+
+impl StdError for FileStrategyError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            Self::Open(e) => Some(e),
+            Self::Read(e) => Some(e),
+        }
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) struct OpenFailed(pub(crate) c_int);
+
+impl Display for OpenFailed {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        write!(f, "open64() returned an error code: {}", self.0)
+    }
+}
+
+impl StdError for OpenFailed {}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) enum ReadExactAtError {
+    ReadAt(ReadAtFailed),
+    AddressOverflow,
+    UnexpectedEof { position: usize },
+}
+
+impl Display for ReadExactAtError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        match self {
+            Self::ReadAt(_) => write!(f, "I/O error reading file"),
+            Self::AddressOverflow => write!(
+                f,
+                "the given address/length pair overflowed the machine's memory range"
+            ),
+            Self::UnexpectedEof { position } => write!(
+                f,
+                "unexpected end-of-file encountered at position: {position}"
+            ),
+        }
+    }
+}
+
+impl StdError for ReadExactAtError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            Self::ReadAt(e) => Some(e),
+            Self::AddressOverflow => None,
+            Self::UnexpectedEof { .. } => None,
+        }
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) enum ReadAtFailed {
+    Syscall(c_int),
+    AddressOutOfBounds,
+}
+
+impl Display for ReadAtFailed {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        match self {
+            Self::Syscall(errno) => write!(f, "pread64() returned an error code: {errno}"),
+            Self::AddressOutOfBounds => {
+                write!(f, "requested address was out-of-bounds for pread64()")
+            }
+        }
+    }
+}
+
+impl StdError for ReadAtFailed {}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub(crate) enum PtraceError {
+    Syscall { errno: c_int, position: usize },
+    AddressOverflow,
+}
+
+impl Display for PtraceError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        match self {
+            Self::Syscall { errno, position } => write!(
+                f,
+                "ptrace(PTRACE_PEEKDATA) returned an error code at position {position}: {errno}",
+            ),
+            Self::AddressOverflow => write!(
+                f,
+                "the given address/length pair overflowed the machine's memory range"
+            ),
+        }
+    }
+}
+
+impl StdError for PtraceError {}
diff --git a/crates/process-reader/src/linux/mod.rs b/crates/process-reader/src/linux/mod.rs
new file mode 100644
index 00000000..21f0f00d
--- /dev/null
+++ b/crates/process-reader/src/linux/mod.rs
@@ -0,0 +1,536 @@
+//! Read memory from another Linux or Android process.
+//!
+//! `process-reader` is a small `no_std` helper crate for copying raw bytes from a
+//! target process into caller-provided buffers. It is intended for crash-reporting
+//! and minidump-writing code that needs to inspect a process without taking a
+//! dependency on the standard library.
+//!
+//! The main entry point is [`ProcessReader`]. A reader can either be created in
+//! automatic mode with [`ProcessReader::new`], or pinned to one of the supported
+//! Linux/Android mechanisms:
+//!
+//! - [`ProcessReader::for_virtual_mem`] uses `process_vm_readv(2)`.
+//! - [`ProcessReader::for_file`] uses `/proc/<pid>/mem`.
+//! - [`ProcessReader::for_ptrace`] uses `ptrace(PTRACE_PEEKDATA)`.
+//!
+//! # Read semantics
+//!
+//! [`ProcessReader::read_at`] attempts to copy bytes from a virtual address in the
+//! target process into the caller's buffer. It returns the number of bytes copied,
+//! in the range `0..=buf.len()`. That number may be smaller than the buffer
+//! length. A short successful read is returned as `Ok(n)`, not as an error, and
+//! callers should only interpret `buf[..n]` as bytes read by the call.
+//!
+//! The target process may modify its memory while it is being read. This crate
+//! does not suspend the target or provide snapshot consistency.
+//!
+//! # Strategy selection
+//!
+//! [`ProcessReader::new`] tries the strategies in this order: `process_vm_readv`,
+//! `/proc/<pid>/mem`, then `ptrace(PTRACE_PEEKDATA)`. The first strategy that
+//! returns `Ok(_)` for a non-empty request selects the strategy for that reader,
+//! even if that successful read is shorter than the requested buffer.
+//! Future reads through the same reader use the selected strategy directly; they
+//! do not fall back to other strategies if the selected strategy later fails for a
+//! different address.
+//!
+//! This keeps the common path small and predictable, but callers should create a
+//! new [`ProcessReader`] if they want to retry automatic strategy selection after
+//! a strategy-specific failure.
+//!
+//! # Error model
+//!
+//! [`ProcessReader::read_at`] returns [`ReadError`] only when the selected strategy
+//! reports an error, or when automatic strategy selection cannot get any strategy
+//! to return a successful read. Short successful reads are reported as `Ok(n)`.
+//!
+//! When exactly one strategy failed, [`core::error::Error::source`] returns that
+//! strategy's lower-level error. When automatic selection fails because every
+//! strategy failed, there is no single root cause, so `source()` returns `None`.
+//! Use [`ReadError::virtual_mem_error`], [`ReadError::file_error`], and
+//! [`ReadError::ptrace_error`] to inspect the individual strategy failures.
+//!
+//! The contents of the destination buffer are unspecified after an error. Some
+//! strategies can fail after writing part of the requested range, and errors do
+//! not report how many bytes were copied before the failure.
+//!
+//! # Platform support
+//!
+//! This crate supports Linux and Android. Other operating systems fail to compile.
+//! The intended Android targets are contemporary Android systems; very old Android
+//! releases are not part of the supported configuration.
+//!
+//! # Example
+//!
+//! ```no_run
+//! # fn example() -> Result<(), process_reader::ReadError> {
+//! use process_reader::ProcessReader;
+//!
+//! let pid = 12345 as libc::pid_t;
+//! let reader = ProcessReader::new(pid);
+//!
+//! let mut bytes = [0u8; 16];
+//! let bytes_read = reader.read_at(0x1000, &mut bytes)?;
+//! let bytes = &bytes[..bytes_read];
+//! # let _ = bytes;
+//! # Ok(())
+//! # }
+//! ```
+
+use self::{error::*, wrapper::*};
+use core::{
+    cell::OnceCell,
+    ffi::{CStr, c_long, c_void},
+    fmt::Write,
+    mem::size_of,
+    ptr,
+};
+
+pub use error::{ReadError, ReadExactError};
+
+mod error;
+mod wrapper;
+
+const PTRACE_PEEKDATA_LEN: usize = size_of::<c_long>();
+
+/// Reads raw bytes from another Linux or Android process.
+///
+/// A `ProcessReader` is bound to a single target process ID. It can either
+/// choose a read strategy automatically with [`ProcessReader::new`], or be
+/// constructed with a fixed strategy using [`ProcessReader::for_virtual_mem`],
+/// [`ProcessReader::for_file`], or [`ProcessReader::for_ptrace`].
+///
+/// The type does not interpret the bytes it reads. It only copies bytes from the
+/// target process into the caller's buffer and reports how many bytes were copied.
+///
+/// # Process state and permissions
+///
+/// The operating system still enforces the usual Linux/Android access checks.
+/// Depending on the chosen strategy, the caller may need suitable ptrace-style
+/// permissions, ownership, dumpability, capabilities, or an already-stopped
+/// tracee.
+///
+/// `ProcessReader` does not suspend the target process, attach to it, detach from
+/// it, or otherwise manage target process lifetime. It also does not provide a
+/// consistent snapshot if the target process mutates memory while it is being
+/// read.
+#[derive(Debug)]
+pub struct ProcessReader {
+    pid: libc::pid_t,
+    style: OnceCell<Style>,
+}
+
+impl ProcessReader {
+    /// Creates a reader that automatically chooses a process-memory read strategy.
+    ///
+    /// The first non-empty call to [`read_at`](Self::read_at) tries the supported
+    /// strategies in this order:
+    ///
+    /// 1. `process_vm_readv(2)`
+    /// 2. `/proc/<pid>/mem`
+    /// 3. `ptrace(PTRACE_PEEKDATA)`
+    ///
+    /// The first strategy that returns `Ok(_)` is cached and used for all
+    /// subsequent reads through this `ProcessReader`. A successful read may be
+    /// shorter than the requested buffer; a short successful read still selects
+    /// the strategy. Subsequent reads do not fall back to another strategy if the
+    /// cached strategy fails.
+    ///
+    /// Empty reads succeed immediately, return `Ok(0)`, and do not select a
+    /// strategy.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `pid < 0`. Passing a negative PID is treated as a caller logic
+    /// error.
+    pub fn new(pid: libc::pid_t) -> Self {
+        Self::assert_valid_pid(pid);
+        Self {
+            pid,
+            style: OnceCell::new(),
+        }
+    }
+
+    /// Creates a reader pinned to the `process_vm_readv(2)` strategy.
+    ///
+    /// Reads performed through the returned reader use only `process_vm_readv`.
+    /// They do not fall back to `/proc/<pid>/mem` or `ptrace`.
+    ///
+    /// This is generally the fastest strategy when the kernel permits it. It can
+    /// also return a short successful read if `process_vm_readv` transfers fewer
+    /// bytes than requested.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `pid < 0`. Passing a negative PID is treated as a caller logic
+    /// error.
+    pub fn for_virtual_mem(pid: libc::pid_t) -> Self {
+        Self::assert_valid_pid(pid);
+        Self {
+            pid,
+            style: OnceCell::from(Style::VirtualMem),
+        }
+    }
+
+    /// Creates a reader pinned to the `/proc/<pid>/mem` strategy.
+    ///
+    /// This constructor opens `/proc/<pid>/mem` immediately and keeps the file
+    /// descriptor open for the lifetime of the returned reader. Reads performed
+    /// through the returned reader use only that file descriptor and do not fall
+    /// back to `process_vm_readv` or `ptrace`.
+    ///
+    /// This strategy currently attempts to fill the whole requested buffer. On
+    /// success, [`read_at`](Self::read_at) returns `Ok(buf.len())`. If the file
+    /// read fails or reaches EOF before the buffer is filled, `read_at` returns an
+    /// error, and the buffer may have been partially overwritten.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`ReadError`] if `/proc/<pid>/mem` could not be opened.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `pid < 0`. Passing a negative PID is treated as a caller logic
+    /// error.
+    pub fn for_file(pid: libc::pid_t) -> Result<Self, ReadError> {
+        Self::assert_valid_pid(pid);
+        let file = Self::open_mem_file_for_pid(pid)
+            .map_err(FileStrategyError::Open)
+            .map_err(|e| ReadError(ReadErrorInner::FileStrategy(e)))?;
+        Ok(Self {
+            pid,
+            style: OnceCell::from(Style::File(file)),
+        })
+    }
+
+    /// Creates a reader pinned to the `ptrace(PTRACE_PEEKDATA)` strategy.
+    ///
+    /// Reads performed through the returned reader use only
+    /// `ptrace(PTRACE_PEEKDATA)`. They do not fall back to `process_vm_readv` or
+    /// `/proc/<pid>/mem`.
+    ///
+    /// This constructor does not call `PTRACE_ATTACH`, `PTRACE_SEIZE`,
+    /// `waitpid`, `PTRACE_CONT`, or `PTRACE_DETACH`. The caller must arrange any
+    /// required ptrace relationship and stopped tracee state before reading.
+    ///
+    /// The requested address does not need to be word-aligned; the implementation
+    /// performs aligned `PTRACE_PEEKDATA` reads internally and copies the requested
+    /// byte range out of those words.
+    ///
+    /// This strategy currently attempts to fill the whole requested buffer. On
+    /// success, [`read_at`](Self::read_at) returns `Ok(buf.len())`. If a ptrace
+    /// read fails before the buffer is filled, `read_at` returns an error, and the
+    /// buffer may have been partially overwritten.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `pid < 0`. Passing a negative PID is treated as a caller logic
+    /// error.
+    pub fn for_ptrace(pid: libc::pid_t) -> Self {
+        Self::assert_valid_pid(pid);
+        Self {
+            pid,
+            style: OnceCell::from(Style::Ptrace),
+        }
+    }
+
+    /// Reads from another process until `buf` is completely filled.
+    ///
+    /// This is a convenience wrapper around [`ProcessReader::read_at`]. Unlike
+    /// [`read_at`](Self::read_at), this method does not return successful short
+    /// reads. It repeatedly calls [`read_at`](Self::read_at), advancing `address`
+    /// and the output buffer by the number of bytes read, until the entire buffer
+    /// has been filled.
+    ///
+    /// If an underlying read fails before the buffer is filled, this method returns
+    /// [`ReadExactError::Read`]. If an underlying read succeeds but returns `0`
+    /// bytes before the buffer is filled, this method returns
+    /// [`ReadExactError::UnexpectedEof`].
+    ///
+    /// On success, all of `buf` has been filled with bytes read from the target
+    /// process.
+    ///
+    /// # Strategy selection
+    ///
+    /// This method uses [`ProcessReader::read_at`] internally, so it follows the
+    /// same strategy-selection rules. In particular, a reader created with
+    /// [`ProcessReader::new`] caches the first strategy that succeeds for a
+    /// non-empty read, even if that read is short. Later reads performed by this
+    /// method continue using the selected strategy.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`ReadExactError::Read`] if [`read_at`](Self::read_at) returns an
+    /// error before the buffer is full.
+    ///
+    /// Returns [`ReadExactError::UnexpectedEof`] if [`read_at`](Self::read_at)
+    /// returns `Ok(0)` before the buffer is full. A zero-length successful read is
+    /// treated as an exact-read failure because this method could not make forward
+    /// progress.
+    ///
+    /// If this method returns an error, `buf` may have been partially overwritten.
+    /// This error type does not report how many bytes were read before the failure.
+    ///
+    /// # Panics
+    ///
+    /// Panics if a successful partial read leaves bytes remaining in `buf`, but
+    /// advancing the read address by the number of bytes read would wrap past the
+    /// end of the address space.
+    pub fn read_exact_at(
+        &self,
+        mut address: usize,
+        mut buf: &mut [u8],
+    ) -> Result<(), ReadExactError> {
+        if buf.is_empty() {
+            return Ok(());
+        }
+
+        loop {
+            let bytes_read = self.read_at(address, buf).map_err(ReadExactError::Read)?;
+            if bytes_read == 0 {
+                return Err(ReadExactError::UnexpectedEof);
+            }
+            if bytes_read == buf.len() {
+                return Ok(());
+            }
+            address = address
+                .checked_add(bytes_read)
+                .expect("requested read will wrap past end of address space");
+            buf = &mut buf[bytes_read..];
+        }
+    }
+
+    /// Attempts to read bytes from the target process at `address`.
+    ///
+    /// This method copies bytes from `address` in the target process into `buf`
+    /// and returns the number of bytes copied. The returned length is in the
+    /// range `0..=buf.len()` and may be smaller than `buf.len()`. A short
+    /// successful read is returned as `Ok(n)`, not as an error, and callers should
+    /// only interpret `buf[..n]` as bytes read by this call.
+    ///
+    /// If `buf` is empty, this method returns `Ok(0)` without performing a system
+    /// call and without selecting a strategy for readers created with
+    /// [`ProcessReader::new`].
+    ///
+    /// The `address` is a virtual address in the target process, not in the
+    /// calling process.
+    ///
+    /// # Strategy behavior
+    ///
+    /// For readers created with [`ProcessReader::new`], the first `Ok(_)` from a
+    /// non-empty read request selects a strategy for the reader. A successful
+    /// read may be shorter than the requested buffer, and a short successful read
+    /// still selects the strategy. Future reads use that selected strategy only.
+    ///
+    /// Readers created with [`ProcessReader::for_virtual_mem`],
+    /// [`ProcessReader::for_file`], or [`ProcessReader::for_ptrace`] always use
+    /// only the requested strategy.
+    ///
+    /// The `process_vm_readv(2)` strategy returns the byte count reported by
+    /// `process_vm_readv`. The `/proc/<pid>/mem` and `ptrace(PTRACE_PEEKDATA)`
+    /// strategies currently attempt to fill the whole buffer and return
+    /// `Ok(buf.len())` on success.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`ReadError`] if the selected strategy reports an error, or if
+    /// automatic strategy selection cannot get any strategy to return success.
+    ///
+    /// A failed read may have partially overwritten `buf`, and the error does not
+    /// report how many bytes were copied before the failure. Callers should not
+    /// rely on the contents of `buf` after an error.
+    pub fn read_at(&self, address: usize, buf: &mut [u8]) -> Result<usize, ReadError> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        if let Some(style) = self.style.get() {
+            return match style {
+                Style::VirtualMem => {
+                    Self::vmem(self.pid, address, buf).map_err(ReadErrorInner::VirtualMemStrategy)
+                }
+                Style::File(file) => Self::file(file, address, buf)
+                    .map(|()| buf.len())
+                    .map_err(ReadErrorInner::FileStrategy),
+                Style::Ptrace => Self::ptrace(self.pid, address, buf)
+                    .map(|()| buf.len())
+                    .map_err(ReadErrorInner::PtraceStrategy),
+            }
+            .map_err(ReadError);
+        }
+
+        const DOUBLE_INIT_MSG: &str = "somehow ProcessReader::style initialized twice";
+
+        let vmem_err = match Self::vmem(self.pid, address, buf) {
+            Ok(len) => {
+                self.style.set(Style::VirtualMem).expect(DOUBLE_INIT_MSG);
+                return Ok(len);
+            }
+            Err(e) => e,
+        };
+
+        let file_err = match Self::open_mem_file_for_pid(self.pid) {
+            Ok(file) => match Self::file(&file, address, buf) {
+                Ok(()) => {
+                    self.style.set(Style::File(file)).expect(DOUBLE_INIT_MSG);
+                    return Ok(buf.len());
+                }
+                Err(e) => e,
+            },
+            Err(e) => FileStrategyError::Open(e),
+        };
+
+        let ptrace_err = match Self::ptrace(self.pid, address, buf) {
+            Ok(()) => {
+                self.style.set(Style::Ptrace).expect(DOUBLE_INIT_MSG);
+                return Ok(buf.len());
+            }
+            Err(e) => e,
+        };
+
+        Err(ReadError(ReadErrorInner::AllStrategies {
+            vmem_err,
+            file_err,
+            ptrace_err,
+        }))
+    }
+    fn assert_valid_pid(pid: libc::pid_t) {
+        assert!(pid >= 0, "pid must be a non-negative process ID");
+    }
+    fn open_mem_file_for_pid(pid: libc::pid_t) -> Result<File, OpenFailed> {
+        // The max length of a string that looks like "/proc/{pid}/mem\0"
+        //
+        // "/proc/" = 6 bytes
+        // "<pid>" = a 32-bit non-negative signed integer. Max: 2147483647 -> 10 bytes
+        // "/mem" = 4 bytes
+        // null terminator = 1 byte
+        const MAX_PROC_MEM_LEN: usize = 6 + 10 + 4 + 1;
+
+        let mut path_c_str = [0u8; MAX_PROC_MEM_LEN];
+        let path_c_str = {
+            let mut writer = ByteSliceWriter::new(&mut path_c_str);
+            write!(writer, "/proc/{pid}/mem\0").unwrap();
+            CStr::from_bytes_until_nul(&path_c_str).unwrap()
+        };
+
+        File::open(path_c_str)
+    }
+    fn vmem(
+        pid: libc::pid_t,
+        address: usize,
+        buf: &mut [u8],
+    ) -> Result<usize, ProcessVmReadvFailed> {
+        let mut local_iov = [libc::iovec {
+            iov_base: buf.as_mut_ptr().cast(),
+            iov_len: buf.len(),
+        }];
+
+        let mut remote_iov = [libc::iovec {
+            iov_base: address as *mut _,
+            iov_len: buf.len(),
+        }];
+
+        let rv = unsafe {
+            libc::process_vm_readv(
+                pid,
+                local_iov.as_mut_ptr(),
+                local_iov.len().try_into().unwrap(),
+                remote_iov.as_mut_ptr(),
+                remote_iov.len().try_into().unwrap(),
+                0,
+            )
+        };
+        if rv == -1 {
+            return Err(ProcessVmReadvFailed(errno()));
+        }
+
+        let bytes_read = usize::try_from(rv).unwrap();
+        Ok(bytes_read)
+    }
+    fn file(fd: &File, position: usize, buf: &mut [u8]) -> Result<(), FileStrategyError> {
+        fd.read_exact_at(position, buf)
+            .map_err(FileStrategyError::Read)
+    }
+    fn ptrace(pid: libc::pid_t, address: usize, buf: &mut [u8]) -> Result<(), PtraceError> {
+        let mut reader = PtraceReader::new(pid, address)?;
+        reader.read_exact(buf)
+    }
+}
+
+struct PtraceReader {
+    pid: libc::pid_t,
+    position: usize,
+    buffer: [u8; PTRACE_PEEKDATA_LEN],
+    buffer_pos: usize,
+}
+
+impl PtraceReader {
+    fn new(pid: libc::pid_t, position: usize) -> Result<Self, PtraceError> {
+        let requested_position = position;
+        let position = requested_position / PTRACE_PEEKDATA_LEN * PTRACE_PEEKDATA_LEN;
+        let buffer = Self::ptrace_peekdata(pid, position)?;
+        let buffer_pos = requested_position - position;
+        Ok(Self {
+            pid,
+            position,
+            buffer,
+            buffer_pos,
+        })
+    }
+    fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<(), PtraceError> {
+        while !buf.is_empty() {
+            let bytes_read = self.read(buf)?;
+            assert!(bytes_read > 0);
+            buf = &mut buf[bytes_read..];
+        }
+        Ok(())
+    }
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, PtraceError> {
+        let buffered_bytes = self.fill_buf()?;
+
+        let bytes_to_read = usize::min(buf.len(), buffered_bytes.len());
+        buf[0..bytes_to_read].copy_from_slice(&buffered_bytes[0..bytes_to_read]);
+        self.buffer_pos += bytes_to_read;
+
+        Ok(bytes_to_read)
+    }
+    fn fill_buf(&mut self) -> Result<&[u8], PtraceError> {
+        if self.buffer_pos == PTRACE_PEEKDATA_LEN {
+            self.position = self
+                .position
+                .checked_add(PTRACE_PEEKDATA_LEN)
+                .ok_or(PtraceError::AddressOverflow)?;
+
+            self.buffer = Self::ptrace_peekdata(self.pid, self.position)?;
+            self.buffer_pos = 0;
+        }
+        Ok(&self.buffer[self.buffer_pos..PTRACE_PEEKDATA_LEN])
+    }
+    fn ptrace_peekdata(
+        pid: libc::pid_t,
+        position: usize,
+    ) -> Result<[u8; PTRACE_PEEKDATA_LEN], PtraceError> {
+        set_errno(0);
+        let rv = unsafe {
+            // ptrace is vararg, so best to explicitly declare types
+            let addr: *mut c_void = position as *mut _;
+            let data: *mut c_void = ptr::null_mut();
+            libc::ptrace(libc::PTRACE_PEEKDATA, pid, addr, data)
+        };
+        let err = errno();
+        if rv == -1 && err != 0 {
+            return Err(PtraceError::Syscall {
+                errno: err,
+                position,
+            });
+        }
+        Ok(rv.to_ne_bytes())
+    }
+}
+
+#[derive(Debug)]
+enum Style {
+    VirtualMem,
+    File(File),
+    Ptrace,
+}
diff --git a/crates/process-reader/src/linux/wrapper.rs b/crates/process-reader/src/linux/wrapper.rs
new file mode 100644
index 00000000..2a8d4241
--- /dev/null
+++ b/crates/process-reader/src/linux/wrapper.rs
@@ -0,0 +1,107 @@
+use super::error::{OpenFailed, ReadAtFailed, ReadExactAtError};
+use core::{
+    ffi::{CStr, c_int},
+    fmt,
+};
+
+pub(crate) struct ByteSliceWriter<'a>(Option<&'a mut [u8]>);
+
+impl<'a> ByteSliceWriter<'a> {
+    pub(crate) fn new(b: &'a mut [u8]) -> Self {
+        Self(Some(b))
+    }
+}
+
+impl<'a> fmt::Write for ByteSliceWriter<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        let buf = self.0.take().unwrap();
+        let (dst, tail) = buf.split_at_mut_checked(s.len()).ok_or(fmt::Error)?;
+        dst.copy_from_slice(s.as_bytes());
+        self.0 = Some(tail);
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct File(c_int);
+
+impl File {
+    pub(crate) fn open(path: &CStr) -> Result<Self, OpenFailed> {
+        loop {
+            let rv = unsafe { libc::open64(path.as_ptr(), libc::O_RDONLY | libc::O_CLOEXEC, 0) };
+            if rv != -1 {
+                return Ok(Self(rv));
+            }
+            let err = errno();
+            if err != libc::EINTR {
+                return Err(OpenFailed(err));
+            }
+        }
+    }
+    pub(crate) fn read_exact_at(
+        &self,
+        position: usize,
+        buf: &mut [u8],
+    ) -> Result<(), ReadExactAtError> {
+        let mut offset = 0;
+
+        while offset < buf.len() {
+            let position = position
+                .checked_add(offset)
+                .ok_or(ReadExactAtError::AddressOverflow)?;
+            let bytes_read = self
+                .read_at(position, &mut buf[offset..])
+                .map_err(ReadExactAtError::ReadAt)?;
+            if bytes_read == 0 {
+                return Err(ReadExactAtError::UnexpectedEof { position });
+            }
+            offset += bytes_read;
+        }
+
+        Ok(())
+    }
+    pub(crate) fn read_at(&self, position: usize, buf: &mut [u8]) -> Result<usize, ReadAtFailed> {
+        let position =
+            libc::off64_t::try_from(position).map_err(|_| ReadAtFailed::AddressOutOfBounds)?;
+
+        loop {
+            let rv = unsafe { libc::pread64(self.0, buf.as_mut_ptr().cast(), buf.len(), position) };
+            if rv != -1 {
+                return Ok(usize::try_from(rv).unwrap());
+            }
+            let err = errno();
+            if err != libc::EINTR {
+                return Err(ReadAtFailed::Syscall(err));
+            }
+        }
+    }
+}
+
+impl Drop for File {
+    fn drop(&mut self) {
+        unsafe {
+            let rv = libc::close(self.0);
+            if rv == -1 {
+                // Not much we can really do here
+            }
+        }
+    }
+}
+
+pub(crate) fn errno() -> c_int {
+    unsafe { *errno_location() }
+}
+
+pub(crate) fn set_errno(value: c_int) {
+    unsafe { *errno_location() = value };
+}
+
+#[cfg(target_os = "linux")]
+fn errno_location() -> *mut c_int {
+    unsafe { libc::__errno_location() }
+}
+
+#[cfg(target_os = "android")]
+fn errno_location() -> *mut c_int {
+    unsafe { libc::__errno() }
+}
diff --git a/src/bin/test.rs b/src/bin/test.rs
index 6486a498..4e6bb687 100644
--- a/src/bin/test.rs
+++ b/src/bin/test.rs
@@ -73,7 +73,7 @@ mod linux {
         use minidump_writer::process_reader::ProcessReader;
 
         let ppid = getppid();
-        let mut dumper = fail_on_soft_error!(
+        let dumper = fail_on_soft_error!(
             soft_errors,
             MinidumpWriterConfig::new(ppid, ppid).build_for_testing(&mut soft_errors)?
         );
@@ -84,7 +84,7 @@ mod linux {
         let expected_stack = 0x11223344usize.to_ne_bytes();
         let expected_heap = 0x55667788usize.to_ne_bytes();
 
-        let validate = |reader: &ProcessReader| -> Result<()> {
+        let validate = |reader: ProcessReader| -> Result<()> {
             let mut val = [0u8; std::mem::size_of::<usize>()];
             let read = reader.read(stack_var, &mut val)?;
             assert_eq!(read, val.len());
@@ -99,30 +99,23 @@ mod linux {
 
         // virtual mem
         {
-            dumper.process_inspector.force_pr_virtual_mem();
-            validate(dumper.process_inspector.process_reader())
+            validate(ProcessReader::for_virtual_mem(&dumper.process_inspector))
                 .map_err(|err| format!("failed to validate memory: {err}"))?;
         }
 
         // file
         {
-            dumper
-                .process_inspector
-                .force_pr_file()
+            let reader = ProcessReader::for_file(&dumper.process_inspector)
                 .map_err(|err| format!("failed to open `/proc/{ppid}/mem`: {err}"))?;
-            validate(dumper.process_inspector.process_reader())
-                .map_err(|err| format!("failed to validate memory: {err}"))?;
+            validate(reader).map_err(|err| format!("failed to validate memory: {err}"))?;
         }
 
         // ptrace
         {
-            dumper.process_inspector.force_pr_ptrace();
-            validate(dumper.process_inspector.process_reader())
+            validate(ProcessReader::for_ptrace(&dumper.process_inspector))
                 .map_err(|err| format!("failed to validate memory: {err}"))?;
         }
 
-        dumper.process_inspector.force_pr_reset();
-
         let stack_res = MinidumpWriter::copy_from_process(
             &dumper.process_inspector,
             stack_var,
diff --git a/src/linux/minidump_writer/mod.rs b/src/linux/minidump_writer/mod.rs
index ee03d8b3..0177da44 100644
--- a/src/linux/minidump_writer/mod.rs
+++ b/src/linux/minidump_writer/mod.rs
@@ -923,7 +923,7 @@ impl MinidumpWriter {
     ) -> Result<Vec<u8>, WriterError> {
         let reader = self.process_inspector.process_reader();
         module_reader::read_build_id_from_module(module_reader::ProcessModuleMemoryReader::new(
-            reader,
+            &reader,
             self.mappings[idx].start_address,
         ))
         .map_err(WriterError::ModuleReaderError)
@@ -935,7 +935,7 @@ impl MinidumpWriter {
     ) -> Result<String, WriterError> {
         let reader = self.process_inspector.process_reader();
         module_reader::read_soname_from_module(module_reader::ProcessModuleMemoryReader::new(
-            reader,
+            &reader,
             self.mappings[idx].start_address,
         ))
         .map_err(WriterError::ModuleReaderError)
diff --git a/src/linux/module_reader.rs b/src/linux/module_reader.rs
index 58452846..7a1ae939 100644
--- a/src/linux/module_reader.rs
+++ b/src/linux/module_reader.rs
@@ -589,7 +589,7 @@ pub trait ReadModuleMemory {
 }
 
 impl<'a> ReadModuleMemory for ProcessModuleMemoryReader<'a> {
-    fn read(&self, offset: u64, length: u64) -> Result<Cow<'a, [u8]>, ModuleMemoryReadError> {
+    fn read(&self, offset: u64, length: u64) -> Result<Cow<'_, [u8]>, ModuleMemoryReadError> {
         self.read(offset, length)
     }
     fn absolute_to_relative(&self, addr: u64) -> Option<u64> {
@@ -604,6 +604,21 @@ impl<'a> ReadModuleMemory for ProcessModuleMemoryReader<'a> {
     }
 }
 
+impl<T: ReadModuleMemory + ?Sized> ReadModuleMemory for &T {
+    fn read(&self, offset: u64, length: u64) -> Result<Cow<'_, [u8]>, ModuleMemoryReadError> {
+        T::read(self, offset, length)
+    }
+    fn absolute_to_relative(&self, addr: u64) -> Option<u64> {
+        T::absolute_to_relative(self, addr)
+    }
+    fn relative_to_absolute(&self, addr: u64) -> Option<u64> {
+        T::relative_to_absolute(self, addr)
+    }
+    fn is_process_memory(&self) -> bool {
+        T::is_process_memory(self)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/src/linux/process_inspection/mod.rs b/src/linux/process_inspection/mod.rs
index c74ea597..bbcc07ec 100644
--- a/src/linux/process_inspection/mod.rs
+++ b/src/linux/process_inspection/mod.rs
@@ -1,17 +1,15 @@
-use {
-    crate::module_reader::{ModuleMemoryReadError, ReadError, ReadModuleMemory},
-    core::ffi::c_int,
-    failspot::failspot,
-    process_backend::{MAX_PATH_LEN, local, regs::*},
-    process_reader::ProcessReader,
-    std::{
-        borrow::Cow,
-        ffi::{CString, OsString},
-        io,
-        os::unix::ffi::OsStringExt,
-        path::PathBuf,
-        rc::Rc,
-    },
+use self::process_reader::ProcessReader;
+use super::maps_reader;
+use crate::module_reader::{ModuleMemoryReadError, ReadError, ReadModuleMemory};
+use core::ffi::c_int;
+use failspot::failspot;
+use process_backend::{MAX_PATH_LEN, local, regs::*};
+use std::{
+    borrow::Cow,
+    ffi::{CString, OsString},
+    io,
+    os::unix::ffi::OsStringExt,
+    path::PathBuf,
 };
 
 pub use process_backend::regs;
@@ -21,53 +19,58 @@ pub mod process_reader;
 #[derive(Debug)]
 pub struct ProcessInspector {
     pid: libc::pid_t,
-    process_reader: ProcessReader,
-    backend: Rc<Backend>,
+    backend: Backend,
 }
 
 #[derive(Debug)]
 pub enum Backend {
-    Local(local::Backend),
+    Local {
+        backend: local::Backend,
+        process_reader_backend: local::ProcessReader,
+    },
 }
 
 impl ProcessInspector {
     pub fn local(pid: libc::pid_t) -> Self {
-        let backend = Rc::new(Backend::Local(local::Backend::new(pid)));
+        let backend = local::Backend::new(pid);
+        let process_reader_backend = backend.process_reader();
 
         ProcessInspector {
             pid,
-            process_reader: ProcessReader::new(pid, Rc::clone(&backend)),
-            backend,
+            backend: Backend::Local {
+                backend,
+                process_reader_backend,
+            },
         }
     }
-    pub fn process_reader(&self) -> &ProcessReader {
-        &self.process_reader
+    pub fn process_reader(&self) -> ProcessReader<'_> {
+        ProcessReader::new(self)
     }
     pub fn stop_process(&self) -> Result<(), Error> {
         failspot!(if StopProcess {
             return Err(Error::Local(local::Error::SigStopFailed(libc::EPERM)));
         });
 
-        match &*self.backend {
-            Backend::Local(l) => l.stop_process().map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.stop_process().map_err(Error::Local),
         }
     }
 
     pub fn continue_process(&self) -> Result<(), Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.continue_process().map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.continue_process().map_err(Error::Local),
         }
     }
 
     pub fn suspend_thread(&self, tid: libc::pid_t) -> Result<(), Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.suspend_thread(tid).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.suspend_thread(tid).map_err(Error::Local),
         }
     }
 
     pub fn resume_thread(&self, tid: libc::pid_t) -> Result<(), Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.resume_thread(tid).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.resume_thread(tid).map_err(Error::Local),
         }
     }
 
@@ -77,8 +80,8 @@ impl ProcessInspector {
         offset: u64,
     ) -> Result<MappedModuleMemoryReader, Error> {
         let c_path = CString::new(path.into().into_os_string().into_vec()).unwrap();
-        match &*self.backend {
-            Backend::Local(l) => l
+        match &self.backend {
+            Backend::Local { backend, .. } => backend
                 .map_module_into_memory(&c_path, offset)
                 .map(MappedModuleMemoryReader::Local)
                 .map_err(Error::Local),
@@ -87,15 +90,15 @@ impl ProcessInspector {
 
     pub fn stat_file(&self, path: impl Into<PathBuf>) -> Result<libc::stat, Error> {
         let c_path = CString::new(path.into().into_os_string().into_vec()).unwrap();
-        match &*self.backend {
-            Backend::Local(l) => l.stat_file(&c_path).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.stat_file(&c_path).map_err(Error::Local),
         }
     }
 
     pub fn read_file(&self, path: impl Into<PathBuf>) -> Result<FileReader, Error> {
         let c_path = CString::new(path.into().into_os_string().into_vec()).unwrap();
-        match &*self.backend {
-            Backend::Local(l) => l
+        match &self.backend {
+            Backend::Local { backend, .. } => backend
                 .read_file(&c_path)
                 .map(FileReader::Local)
                 .map_err(Error::Local),
@@ -104,8 +107,8 @@ impl ProcessInspector {
 
     pub fn read_dir(&self, path: impl Into<PathBuf>) -> Result<DirReader, Error> {
         let c_path = CString::new(path.into().into_os_string().into_vec()).unwrap();
-        match &*self.backend {
-            Backend::Local(l) => l
+        match &self.backend {
+            Backend::Local { backend, .. } => backend
                 .read_dir(&c_path)
                 .map(DirReader::Local)
                 .map_err(Error::Local),
@@ -117,8 +120,10 @@ impl ProcessInspector {
 
         let mut buf = vec![0u8; MAX_PATH_LEN];
 
-        let len = match &*self.backend {
-            Backend::Local(l) => l.read_link(&c_path, &mut buf).map_err(Error::Local)?,
+        let len = match &self.backend {
+            Backend::Local { backend, .. } => {
+                backend.read_link(&c_path, &mut buf).map_err(Error::Local)?
+            }
         };
 
         buf.truncate(len);
@@ -126,21 +131,21 @@ impl ProcessInspector {
     }
 
     pub fn get_gen_regs(&self, tid: libc::pid_t) -> Result<GenRegs, Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.get_gen_regs(tid).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.get_gen_regs(tid).map_err(Error::Local),
         }
     }
 
     pub fn get_fp_regs(&self, tid: libc::pid_t) -> Result<FpRegs, Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.get_fp_regs(tid).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.get_fp_regs(tid).map_err(Error::Local),
         }
     }
 
     #[cfg(target_arch = "x86")]
     pub fn get_fpx_regs(&self, tid: libc::pid_t) -> Result<FpxRegs, Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.get_fpx_regs(tid).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.get_fpx_regs(tid).map_err(Error::Local),
         }
     }
 
@@ -150,8 +155,10 @@ impl ProcessInspector {
         pid: libc::pid_t,
         addr: usize,
     ) -> Result<[u8; core::mem::size_of::<libc::c_long>()], Error> {
-        match &*self.backend {
-            Backend::Local(l) => l.ptrace_peekuser(pid, addr).map_err(Error::Local),
+        match &self.backend {
+            Backend::Local { backend, .. } => {
+                backend.ptrace_peekuser(pid, addr).map_err(Error::Local)
+            }
         }
     }
 }
@@ -161,14 +168,6 @@ pub enum FileReader {
     Local(local::FileReader),
 }
 
-impl FileReader {
-    fn read_at(&self, buf: &mut [u8], offset: u64) -> Result<usize, Error> {
-        match self {
-            Self::Local(l) => l.read_at(buf, offset).map_err(Error::Local),
-        }
-    }
-}
-
 impl io::Read for FileReader {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
@@ -198,22 +197,9 @@ impl Iterator for DirReader {
 
 #[doc(hidden)]
 impl ProcessInspector {
-    pub fn force_pr_reset(&mut self) {
-        self.process_reader = ProcessReader::new(self.pid, Rc::clone(&self.backend))
-    }
-    pub fn force_pr_virtual_mem(&mut self) {
-        self.process_reader = ProcessReader::for_virtual_mem(self.pid, Rc::clone(&self.backend))
-    }
-    pub fn force_pr_file(&mut self) -> Result<(), Error> {
-        self.process_reader = ProcessReader::for_file(self.pid, Rc::clone(&self.backend))?;
-        Ok(())
-    }
-    pub fn force_pr_ptrace(&mut self) {
-        self.process_reader = ProcessReader::for_ptrace(self.pid, Rc::clone(&self.backend));
-    }
     pub fn fail_one_syscall_with(&self, errno: c_int) {
-        match &*self.backend {
-            Backend::Local(l) => l.fail_one_syscall_with(errno),
+        match &self.backend {
+            Backend::Local { backend, .. } => backend.fail_one_syscall_with(errno),
         }
     }
 }
@@ -264,7 +250,7 @@ impl ReadModuleMemory for MappedModuleMemoryReader {
     }
 }
 
-#[derive(Debug, thiserror::Error, serde::Serialize)]
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
 pub enum Error {
     #[error("an error occurred running a syscall directly")]
     Local(#[source] local::Error),
diff --git a/src/linux/process_inspection/process_reader.rs b/src/linux/process_inspection/process_reader.rs
index a61e8376..d7cc3bd9 100644
--- a/src/linux/process_inspection/process_reader.rs
+++ b/src/linux/process_inspection/process_reader.rs
@@ -1,124 +1,62 @@
-use {
-    super::{Backend, Error, FileReader},
-    core::{ffi::c_long, mem},
-    std::{ffi::CString, rc::Rc, sync::OnceLock},
+use super::{
+    Backend, Error, ProcessInspector,
+    maps_reader::{MappingInfo, MapsReaderError},
 };
+use crate::module_reader::ProcessModuleMemoryReader;
 
-#[derive(Debug)]
-enum Style {
-    /// Uses [`process_vm_readv`](https://linux.die.net/man/2/process_vm_readv)
-    /// to read the memory.
-    ///
-    /// This is not available on old <3.2 (really, ancient) kernels, and requires
-    /// the same permissions as ptrace
-    VirtualMem,
-    /// Reads the memory from `/proc/<pid>/mem`
-    ///
-    /// Available on basically all versions of Linux, but could fail if the process
-    /// has insufficient privileges, ie ptrace
-    File(FileReader),
-    /// Reads the memory with [ptrace (`PTRACE_PEEKDATA`)](https://man7.org/linux/man-pages/man2/ptrace.2.html)
-    ///
-    /// Reads data one word at a time, so slow, but fairly reliable, as long as
-    /// the process can be ptraced
-    Ptrace,
-    /// No methods succeeded, generally there isn't a case where failing a syscall
-    /// will work if called again
-    Unavailable,
-}
-
-#[derive(Debug, thiserror::Error, serde::Serialize)]
-pub enum CopyFromProcessError {
-    #[error("Copy from process {child} failed (source {src}, offset: {offset}, length: {length})")]
-    StrategyFailed {
-        child: libc::pid_t,
-        src: usize,
-        offset: usize,
-        length: usize,
-        source: StrategyError,
-    },
-    #[error("all strategies for reading a process failed")]
-    AllStrategiesFailed {
-        vmem: StrategyError,
-        file: StrategyError,
-        ptrace: (StrategyError, usize),
-    },
-    #[error("process reading is unavailable")]
-    Unavailable,
-    #[error("an invalid argument was passed")]
-    InvalidArgument,
-}
+use process_backend::local;
 
-#[derive(Debug, thiserror::Error, serde::Serialize)]
-pub enum StrategyError {
-    #[error(transparent)]
-    Backend(Error),
-    #[error("an unexpected end of file was reached")]
-    UnexpectedEof,
-}
+pub type ProcessHandle = libc::pid_t;
 
-pub struct ProcessReader {
-    /// The pid of the child to read
-    pid: libc::pid_t,
-    style: OnceLock<Style>,
-    backend: Rc<Backend>,
+#[derive(Debug)]
+pub struct ProcessReader<'a> {
+    process_inspector: &'a ProcessInspector,
+    forced_backend: Option<ForcedBackend>,
 }
 
-impl std::fmt::Debug for ProcessReader {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self.style.get() {
-            Some(Style::VirtualMem) => "process_vm_readv",
-            Some(Style::File(_)) => "/proc/<pid>/mem",
-            Some(Style::Ptrace) => "PTRACE_PEEKDATA",
-            Some(Style::Unavailable) => "Unavailable",
-            None => "unknown",
-        };
-
-        f.write_str(s)
-    }
+#[derive(Debug)]
+enum ForcedBackend {
+    Local(local::ProcessReader),
 }
 
-impl ProcessReader {
-    /// Creates a [`Self`] for the specified process id, the method used will
-    /// be probed for on the first access
-    #[inline]
-    pub(super) fn new(pid: libc::pid_t, backend: Rc<Backend>) -> Self {
+impl<'a> ProcessReader<'a> {
+    pub fn new(process_inspector: &'a ProcessInspector) -> Self {
         Self {
-            pid,
-            style: OnceLock::default(),
-            backend,
+            process_inspector,
+            forced_backend: None,
         }
     }
-
-    #[inline]
-    #[doc(hidden)]
-    pub(super) fn for_virtual_mem(pid: libc::pid_t, backend: Rc<Backend>) -> Self {
+    pub fn for_virtual_mem(process_inspector: &'a ProcessInspector) -> Self {
+        let forced_backend = match &process_inspector.backend {
+            Backend::Local { backend, .. } => {
+                ForcedBackend::Local(backend.process_reader_for_virtual_mem())
+            }
+        };
         Self {
-            pid,
-            style: OnceLock::from(Style::VirtualMem),
-            backend,
+            process_inspector,
+            forced_backend: Some(forced_backend),
         }
     }
-
-    #[inline]
-    #[doc(hidden)]
-    pub(super) fn for_file(pid: libc::pid_t, backend: Rc<Backend>) -> Result<Self, Error> {
-        let file = Self::open_file(&backend, format!("/proc/{pid}/mem"))?;
-
+    pub fn for_file(process_inspector: &'a ProcessInspector) -> Result<Self, Error> {
+        let forced_backend = match &process_inspector.backend {
+            Backend::Local { backend, .. } => {
+                ForcedBackend::Local(backend.process_reader_for_file().map_err(Error::Local)?)
+            }
+        };
         Ok(Self {
-            pid,
-            style: OnceLock::from(Style::File(file)),
-            backend,
+            process_inspector,
+            forced_backend: Some(forced_backend),
         })
     }
-
-    #[inline]
-    #[doc(hidden)]
-    pub(super) fn for_ptrace(pid: libc::pid_t, backend: Rc<Backend>) -> Self {
+    pub fn for_ptrace(process_inspector: &'a ProcessInspector) -> Self {
+        let forced_backend = match &process_inspector.backend {
+            Backend::Local { backend, .. } => {
+                ForcedBackend::Local(backend.process_reader_for_ptrace())
+            }
+        };
         Self {
-            pid,
-            style: OnceLock::from(Style::Ptrace),
-            backend,
+            process_inspector,
+            forced_backend: Some(forced_backend),
         }
     }
 
@@ -126,109 +64,68 @@ impl ProcessReader {
     ///
     /// Returns the number of bytes read.
     pub fn read(&self, src: usize, dst: &mut [u8]) -> Result<usize, CopyFromProcessError> {
-        if let Some(rs) = self.style.get() {
-            return match rs {
-                Style::VirtualMem => Self::vmem(&self.backend, src, dst).map_err(|e| (e, 0)),
-                Style::File(file) => Self::file(file, src, dst).map_err(|e| (e, 0)),
-                Style::Ptrace => Self::ptrace(&self.backend, src, dst),
-                Style::Unavailable => return Err(CopyFromProcessError::Unavailable),
+        if let Some(forced_backend) = &self.forced_backend {
+            match forced_backend {
+                ForcedBackend::Local(process_reader_backend) => process_reader_backend
+                    .read_at(src, dst)
+                    .map_err(Error::Local),
             }
-            .map_err(|(source, offset)| CopyFromProcessError::StrategyFailed {
-                child: self.pid,
-                src,
-                offset,
-                length: dst.len(),
-                source,
-            });
-        }
-
-        const DOUBLE_INIT_MSG: &str = "somehow MemReader initialized twice";
-
-        // Attempt to read in order of speed
-        let vmem = match Self::vmem(&self.backend, src, dst) {
-            Ok(len) => {
-                self.style.set(Style::VirtualMem).expect(DOUBLE_INIT_MSG);
-                return Ok(len);
+        } else {
+            match &self.process_inspector.backend {
+                Backend::Local {
+                    process_reader_backend,
+                    ..
+                } => process_reader_backend
+                    .read_at(src, dst)
+                    .map_err(Error::Local),
             }
-            Err(err) => err,
-        };
-
-        let file = match Self::open_file(&self.backend, format!("/proc/{}/mem", self.pid)) {
-            Ok(fd) => match Self::file(&fd, src, dst) {
-                Ok(len) => {
-                    self.style.set(Style::File(fd)).expect(DOUBLE_INIT_MSG);
-                    return Ok(len);
-                }
-                Err(err) => err,
-            },
-            Err(err) => StrategyError::Backend(err),
-        };
-
-        let ptrace = match Self::ptrace(&self.backend, src, dst) {
-            Ok(len) => {
-                self.style.set(Style::Ptrace).expect(DOUBLE_INIT_MSG);
-                return Ok(len);
-            }
-            Err(err) => err,
-        };
-
-        self.style.set(Style::Unavailable).expect(DOUBLE_INIT_MSG);
-        Err(CopyFromProcessError::AllStrategiesFailed { vmem, file, ptrace })
-    }
-
-    fn open_file(backend: &Backend, path: String) -> Result<FileReader, Error> {
-        let c_path = CString::new(path).unwrap();
-
-        match backend {
-            Backend::Local(l) => l
-                .read_file(&c_path)
-                .map(FileReader::Local)
-                .map_err(Error::Local),
-        }
-    }
-
-    #[inline]
-    fn vmem(backend: &Backend, src: usize, dst: &mut [u8]) -> Result<usize, StrategyError> {
-        match backend {
-            Backend::Local(l) => l.read_process_io_vec(dst, src).map_err(Error::Local),
         }
-        .map_err(StrategyError::Backend)
+        .map_err(CopyFromProcessError::Backend)
     }
+    /// Find the address at which a module with the given name is loaded in the process.
+    pub fn find_module(
+        &self,
+        module_name: &str,
+    ) -> Result<ProcessModuleMemoryReader<'_>, FindModuleError> {
+        MappingInfo::for_pid(self.process_inspector, self.process_inspector.pid, None)?
+            .into_iter()
+            .find_map(|m| {
+                let mmem = ProcessModuleMemoryReader::new(self, m.start_address);
+                let name = m.name.as_ref().and_then(|s| s.to_str())?;
+                if name == module_name {
+                    return Some(mmem);
+                }
+                // Check whether the SO_NAME matches the module name.
+                //
+                // For now, only check the SO_NAME of Android APKS, because libraries may be mapped
+                // directly from within an APK. See bug 1982902.
+                #[cfg(target_os = "android")]
+                if name.ends_with(".apk") {
+                    if let Ok(so_name) = crate::module_reader::read_soname_from_module(&mmem) {
+                        if so_name == name {
+                            return Some(mmem);
+                        }
+                    }
+                }
 
-    #[inline]
-    fn file(reader: &FileReader, src: usize, dst: &mut [u8]) -> Result<usize, StrategyError> {
-        let mut offset = 0;
-
-        while offset < dst.len() {
-            let bytes_read = reader
-                .read_at(&mut dst[offset..], (src + offset).try_into().unwrap())
-                .map_err(StrategyError::Backend)?;
-            if bytes_read == 0 {
-                return Err(StrategyError::UnexpectedEof);
-            }
-            offset += bytes_read;
-        }
-
-        Ok(dst.len())
+                None
+            })
+            .ok_or(FindModuleError::ModuleNotFound)
     }
+}
 
-    #[inline]
-    fn ptrace(
-        backend: &Backend,
-        src: usize,
-        dst: &mut [u8],
-    ) -> Result<usize, (StrategyError, usize)> {
-        let mut offset = 0;
-
-        for chunk in dst.chunks_mut(mem::size_of::<c_long>()) {
-            let word = match backend {
-                Backend::Local(l) => l.ptrace_peekdata(src + offset).map_err(Error::Local),
-            }
-            .map_err(|e| (StrategyError::Backend(e), offset))?;
-            offset += word.len();
-            chunk.copy_from_slice(&word[0..chunk.len()]);
-        }
+#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
+pub enum CopyFromProcessError {
+    #[error("an error occurred calling ProcessReader")]
+    Backend(Error),
+    #[error("an invalid argument was passed")]
+    InvalidArgument,
+}
 
-        Ok(dst.len())
-    }
+#[derive(Debug, thiserror::Error, serde::Serialize)]
+pub enum FindModuleError {
+    #[error("Module not found")]
+    ModuleNotFound,
+    #[error("Failed to read process module mappings")]
+    MappingError(#[from] MapsReaderError),
 }
diff --git a/src/mac/process_reader.rs b/src/mac/process_reader.rs
index 978b4cf6..a18e1287 100644
--- a/src/mac/process_reader.rs
+++ b/src/mac/process_reader.rs
@@ -10,13 +10,17 @@ use {
         task_info::{TASK_DYLD_ALL_IMAGE_INFO_64, TASK_DYLD_INFO, task_dyld_info},
         vm::mach_vm_read_overwrite,
     },
-    std::mem::{MaybeUninit, size_of},
+    std::{
+        marker::PhantomData,
+        mem::{MaybeUninit, size_of},
+    },
 };
 
 pub type ProcessHandle = mach2::mach_types::task_t;
 
-pub struct ProcessReader {
+pub struct ProcessReader<'a> {
     process: ProcessHandle,
+    phantom: PhantomData<&'a ()>,
 }
 
 #[repr(C)]
@@ -73,9 +77,12 @@ pub enum FindModuleError {
     FailedToReadModule(#[from] CopyFromProcessError),
 }
 
-impl ProcessReader {
-    pub fn new(process: ProcessHandle) -> ProcessReader {
-        ProcessReader { process }
+impl ProcessReader<'_> {
+    pub fn new(process: ProcessHandle) -> ProcessReader<'static> {
+        ProcessReader {
+            process,
+            phantom: PhantomData,
+        }
     }
 
     pub fn read(&self, src: usize, dst: &mut [u8]) -> Result<usize, CopyFromProcessError> {
diff --git a/src/module_reader.rs b/src/module_reader.rs
index 26ee48cd..0215b623 100644
--- a/src/module_reader.rs
+++ b/src/module_reader.rs
@@ -14,12 +14,12 @@ pub use crate::windows::module_reader::*;
 pub use crate::mac::module_reader::*;
 
 pub struct ProcessModuleMemoryReader<'a> {
-    pub(super) reader: &'a ProcessReader,
+    pub(super) reader: &'a ProcessReader<'a>,
     pub(super) start_address: u64,
 }
 
 impl<'a> ProcessModuleMemoryReader<'a> {
-    pub fn new(reader: &'a ProcessReader, start_address: usize) -> Self {
+    pub fn new(reader: &'a ProcessReader<'a>, start_address: usize) -> Self {
         Self {
             reader,
             start_address: start_address as u64,
diff --git a/src/process_reader.rs b/src/process_reader.rs
index 38d75ba9..706017df 100644
--- a/src/process_reader.rs
+++ b/src/process_reader.rs
@@ -9,7 +9,7 @@ pub use crate::mac::process_reader::*;
 
 use std::{ffi::CString, mem::MaybeUninit};
 
-impl ProcessReader {
+impl ProcessReader<'_> {
     #[inline]
     pub fn read_to_vec(
         &self,
diff --git a/src/windows/process_reader.rs b/src/windows/process_reader.rs
index 8fc5889d..59f6d686 100644
--- a/src/windows/process_reader.rs
+++ b/src/windows/process_reader.rs
@@ -4,6 +4,7 @@ use {
     std::{
         convert::TryInto,
         ffi::OsString,
+        marker::PhantomData,
         mem::{MaybeUninit, size_of},
         os::windows::ffi::OsStringExt,
     },
@@ -11,8 +12,9 @@ use {
 
 pub type ProcessHandle = ffi::HANDLE;
 
-pub struct ProcessReader {
+pub struct ProcessReader<'a> {
     process: ProcessHandle,
+    phantom: PhantomData<&'a ()>,
 }
 
 #[derive(Debug, thiserror::Error, serde::Serialize)]
@@ -35,9 +37,12 @@ pub enum FindModuleError {
     ModuleListTooLarge,
 }
 
-impl ProcessReader {
-    pub fn new(process: ProcessHandle) -> ProcessReader {
-        ProcessReader { process }
+impl ProcessReader<'_> {
+    pub fn new(process: ProcessHandle) -> ProcessReader<'static> {
+        ProcessReader {
+            process,
+            phantom: PhantomData,
+        }
     }
 
     pub fn read(&self, src: usize, dst: &mut [u8]) -> Result<usize, CopyFromProcessError> {