ci(test): strip test binaries and record CI resource usage

--all-features test binaries statically link the full dependency
closure across hundreds of binaries, running target/ up to roughly
100 GB and exhausting a stock runner's disk mid-link, where the
linker's mmap-backed write aborts with SIGBUS instead of a clean
ENOSPC. Stripping symbols from test binaries removes over a third of
each one, and recording memory/disk/CPU before and after the build
makes future exhaustion attributable instead of read as a linker
crash.

Author: farhan-syah

.github/workflows/test.yml

@@ -75,12 +75,19 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
-      - name: Free disk space
-        # The --all-features suite links hundreds of statically linked test
-        # binaries into target/; on a stock runner that fills the root disk,
-        # and the linker (rust-lld) then fails its mmap-backed output write
-        # with SIGBUS (signal 7) at link time. Reclaim the large preinstalled
-        # toolchains this build never uses so the link always has headroom.
+      - name: Reclaim disk and record resources
+        # Building the workspace's test binaries with --all-features writes on
+        # the order of 100 GB into target/: every test binary statically links
+        # the full dependency closure and lands in the hundreds of MB, and there
+        # are hundreds of them. A stock runner starts with barely more free
+        # space than that, and when it runs out mid-link the linker's
+        # memory-mapped write aborts with SIGBUS (signal 7) rather than a clean
+        # ENOSPC — which reads like a linker crash and not a full disk.
+        #
+        # Reclaim the large preinstalled toolchains this build never uses, then
+        # record the resources a failed mmap actually depends on. The `df` runs
+        # BEFORE the build, so it shows the headroom available to it, not what
+        # remained; read it as the budget, not the outcome.
         run: |
           sudo rm -rf \
             /usr/local/lib/android \
@@ -89,7 +96,9 @@ jobs:
             /opt/hostedtoolcache/CodeQL \
             /usr/share/swift
           sudo docker image prune -af || true
-          df -h /
+          echo "== memory =="; free -h
+          echo "== filesystems =="; df -h / /tmp /dev/shm
+          echo "== cpus =="; nproc
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
@@ -119,6 +128,15 @@ jobs:
             --all-features \
             --cargo-profile ci --profile ci \
             --no-fail-fast
+      - name: Record disk after build
+        if: always()
+        # Counterpart to the pre-build reading: that one is the budget, this is
+        # what the build actually left. Runs even on failure, so a linker abort
+        # can be attributed to a full disk instead of inferred. `target/` is
+        # reported separately because it is what grows.
+        run: |
+          echo "== filesystems =="; df -h / /tmp /dev/shm
+          echo "== target/ =="; du -sh target 2>/dev/null || true
       - name: Upload JUnit report
         if: always()
         uses: actions/upload-artifact@v7

Cargo.toml

@@ -273,6 +273,15 @@ debug = false
 inherits = "dev"
 debug = false
 incremental = false
+# Drop symbol tables from the linked test binaries. With --all-features every
+# test binary statically links the full dependency closure, and there are
+# hundreds of them, so target/ runs to roughly 100 GB — enough to exhaust a CI
+# runner mid-link, where the linker's memory-mapped write aborts with SIGBUS
+# instead of reporting a full disk. Stripping removes better than a third of
+# each binary, which is the difference between fitting and not. Backtraces here
+# are already unsymbolised (`debug = false`), so this costs no diagnostic value
+# the profile had.
+strip = true
 
 [profile.debugging]
 inherits = "dev"