Use mmap for faster warn_missing_py_init

.github/workflows/release.yml

@@ -81,7 +81,7 @@ jobs:
           brew install gnu-tar
           echo "/usr/local/opt/gnu-tar/libexec/gnubin" >> $GITHUB_PATH
 
-      # Those two will also create target/${{ matrix.target }}/maturin
+      # Those two will also create target/maturin/maturin
       - name: Build wheel (linux x86_64)
         if: matrix.target == 'x86_64-unknown-linux-musl'
         run: |
@@ -111,12 +111,17 @@ jobs:
       - name: Archive binary (windows)
         if: matrix.os == 'windows-latest'
         run: |
-          cd target/${{ matrix.target }}/release
-          7z a ../../../${{ matrix.name }} ${{ github.event.repository.name }}.exe
+          7z a ${{ matrix.name }} target/maturin/${{ github.event.repository.name }}.exe
+
+      - name: Archive binary (linux)
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          cd target/maturin
+          tar czvf ../../${{ matrix.name }} ${{ github.event.repository.name }}
           cd -
 
-      - name: Archive binary (linux and macOS)
-        if: matrix.os != 'windows-latest'
+      - name: Archive binary (macOS x86_64)
+        if: matrix.os == 'macos-latest'
         run: |
           cd target/${{ matrix.target }}/release
           tar czvf ../../../${{ matrix.name }} ${{ github.event.repository.name }}
@@ -213,7 +218,7 @@ jobs:
             --compatibility ${{ matrix.platform.compatibility }} \
             --features password-storage
       - name: Archive binary
-        run: tar czvf target/release/maturin-${{ matrix.platform.target }}.tar.gz -C target/${{ matrix.platform.target }}/release maturin
+        run: tar czvf target/release/maturin-${{ matrix.platform.target }}.tar.gz -C target/maturin maturin
       - name: Upload wheel artifacts
         # loongarch64 is not allowed to publish to pypi currently, see https://github.com/pypi/warehouse/blob/348117529910181cb8c14e9b5fb00fcf4dbaf07c/warehouse/forklift/legacy.py#L114-L185
         if: ${{ !contains(fromJson('["loongarch64-unknown-linux-musl"]'), matrix.platform.target) }}

Cargo.toml

@@ -144,6 +144,8 @@ cargo-cyclonedx = { version = "0.5.7", optional = true }
 pretty_assertions = { version = "1.3.0", optional = true }
 which = { version = "8.0.0", optional = true }
 
+memmap2 = "0.9.9"
+
 [dev-dependencies]
 expect-test = "1.4.1"
 fs4 = { version = "0.13.1", features = ["fs-err3"] }

src/build_context.rs

@@ -1048,32 +1048,37 @@ impl BuildContext {
             .cloned()
             .ok_or_else(|| anyhow!(error_msg,))?;
 
+        self.stage_artifact(&mut artifact)?;
+
         if let Some(extension_name) = extension_name {
-            // globin has an issue parsing MIPS64 ELF, see https://github.com/m4b/goblin/issues/274
+            // goblin has an issue parsing MIPS64 ELF, see https://github.com/m4b/goblin/issues/274
             // But don't fail the build just because we can't emit a warning
             let _ = warn_missing_py_init(&artifact.path, extension_name);
         }
-
-        self.copy_artifact_for_repair(&mut artifact)?;
         Ok((artifact, result.out_dirs))
     }
 
-    /// Copy an artifact to a staging directory so that auditwheel repair can
-    /// modify it in-place without altering the original cargo build output.
-    /// This prevents errors on subsequent rebuilds where cargo skips
-    /// recompilation.
+    /// Move an artifact to a private staging directory so that:
+    /// 1. `warn_missing_py_init` can safely mmap the file without risk of
+    ///    concurrent modification by cargo / rust-analyzer.
+    /// 2. Auditwheel repair can modify it in-place without altering the
+    ///    original cargo build output.
     ///
-    /// Only performs the copy when auditwheel mode is `Repair`, since that is
-    /// the only mode that modifies artifacts in-place.
-    fn copy_artifact_for_repair(&self, artifact: &mut BuildArtifact) -> Result<()> {
-        if self.editable || !matches!(self.auditwheel, AuditWheelMode::Repair) {
-            return Ok(());
-        }
+    /// Uses `fs::rename` for an atomic move (avoids copying multi-GB debug
+    /// artifacts), falling back to `fs::copy` when the rename fails (e.g.
+    /// cross-device).
+    fn stage_artifact(&self, artifact: &mut BuildArtifact) -> Result<()> {
         let maturin_build = self.target_dir.join(env!("CARGO_PKG_NAME"));
         fs::create_dir_all(&maturin_build)?;
         let artifact_path = &artifact.path;
         let new_artifact_path = maturin_build.join(artifact_path.file_name().unwrap());
-        fs::copy(artifact_path, &new_artifact_path)?;
+        // Remove any stale file at the destination so that `fs::rename` succeeds
+        // on Windows (where rename fails if the destination already exists).
+        let _ = fs::remove_file(&new_artifact_path);
+        if fs::rename(artifact_path, &new_artifact_path).is_err() {
+            // Rename fails across filesystem boundaries, fall back to copy
+            fs::copy(artifact_path, &new_artifact_path)?;
+        }
         artifact.path = new_artifact_path.normalize()?.into_path_buf();
         Ok(())
     }
@@ -1322,7 +1327,7 @@ impl BuildContext {
             policies.push(policy);
             ext_libs.push(external_libs);
 
-            self.copy_artifact_for_repair(&mut artifact)?;
+            self.stage_artifact(&mut artifact)?;
             artifact_paths.push(artifact);
         }
         let policy = policies.iter().min_by_key(|p| p.priority).unwrap();

src/compile.rs

@@ -9,7 +9,7 @@ use fs_err::{self as fs, File};
 use normpath::PathExt;
 use std::collections::HashMap;
 use std::env;
-use std::io::{BufReader, Read};
+use std::io::BufReader;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::str;
@@ -753,11 +753,13 @@ fn compile_target(
 #[instrument(skip_all)]
 pub fn warn_missing_py_init(artifact: &Path, module_name: &str) -> Result<()> {
     let py_init = format!("PyInit_{module_name}");
-    let mut fd = File::open(artifact)?;
-    let mut buffer = Vec::new();
-    fd.read_to_end(&mut buffer)?;
+    let fd = File::open(artifact)?;
+    // SAFETY: The caller stages (moves/copies) the artifact into a private
+    // directory before invoking this function, so no concurrent process
+    // (e.g. cargo / rust-analyzer) can modify it while we have it mapped.
+    let mmap = unsafe { memmap2::Mmap::map(&fd).context("mmap failed")? };
     let mut found = false;
-    match goblin::Object::parse(&buffer)? {
+    match goblin::Object::parse(&mmap)? {
         goblin::Object::Elf(elf) => {
             for dyn_sym in elf.dynsyms.iter() {
                 if py_init == elf.dynstrtab[dyn_sym.st_name] {

tests/common/pep517.rs

@@ -94,18 +94,10 @@ fn insert_path(env_var: &str, new_path: &Path) -> String {
         .expect("PATH is not valid utf8")
 }
 
-/// Whether cargo built the shared library for the specified cargo profile in the test target
-/// directory.
+/// Whether cargo built for the specified cargo profile in the test target directory.
 pub fn target_has_profile(unique_name: &str, profile: &str) -> bool {
-    let shared_library = if cfg!(windows) {
-        "pyo3_pure.dll"
-    } else if cfg!(target_os = "macos") {
-        "libpyo3_pure.dylib"
-    } else {
-        "libpyo3_pure.so"
-    };
-    PathBuf::from(target_dir(unique_name))
-        .join(profile)
-        .join(shared_library)
-        .is_file()
+    let profile_dir = PathBuf::from(target_dir(unique_name)).join(profile);
+    // Check for cargo's .fingerprint directory which is always created for the
+    // profile that was used, and is not affected by maturin's artifact staging.
+    profile_dir.join(".fingerprint").is_dir()
 }