Clear a stale .done marker before reusing a dump path

The completion marker is meant to tell a watcher the .rdump is fully written.
On a fixed (reused) dump path the previous run's .done lingered while the new
dump was being truncated and rewritten, so a watcher could ship the
half-written file -- exactly what the marker should prevent. Remove the marker
before truncation and re-create it only on completion. CI now pre-plants a
non-empty .done and requires it to come back empty.

https://claude.ai/code/session_017skw8BsHkF8wur7Pf4G9W5

Author: claude

README.md

@@ -167,7 +167,9 @@ rdump.oom_dump_marker=1   ; after a complete dump, also create "<path>.done"
 
 The `<path>.done` file is created (empty, `0600`) only once the dump is fully
 written and closed — wait for `oom-1234.rdump.done`, then ship
-`oom-1234.rdump`. This gives the atomic-visibility guarantee a temp-file +
+`oom-1234.rdump`. When a dump reuses a path, the old marker is removed *before*
+the new dump is truncated and re-created only when it completes, so a `.done` is
+never stale over a half-rewritten file. This gives the atomic-visibility guarantee a temp-file +
 `rename` would, without the rename's downsides, and works on the OOM death path
 (it's a plain `open`/`close`). There is deliberately **no PHP completion
 callback**: the OOM dump runs inside the engine's error handler on a process that

ci/build-and-test.sh

@@ -243,16 +243,23 @@ rm -rf "$BUDGET_DIR"
 # --- OOM dump completion marker -------------------------------------
 # With rdump.oom_dump_marker=1 a "<path>.done" must appear once the dump is
 # fully written, so a directory watcher can wait for it instead of racing the
-# half-written .rdump.
+# half-written .rdump. A stale marker from a previous dump to the same path
+# must be cleared first: pre-plant a non-empty .done and require it to come
+# back empty (cleared, then re-created on completion), never left stale.
 MARKER_DIR=/tmp/rdump-marker
 rm -rf "$MARKER_DIR"; mkdir -p "$MARKER_DIR"
+MARKER_DUMP="$MARKER_DIR/fixed.rdump"
+printf STALE > "$MARKER_DUMP.done"
 php -d extension="$SO" -d memory_limit=8M \
-    -d rdump.oom_dump="$MARKER_DIR/oom-%p.rdump" -d rdump.oom_dump_marker=1 \
+    -d rdump.oom_dump="$MARKER_DUMP" -d rdump.oom_dump_marker=1 \
     -r 'function r(){ r(); } r();' >/dev/null 2>&1 || true
-if ls "$MARKER_DIR"/oom-*.rdump.done >/dev/null 2>&1; then
-    echo "oom-marker OK"
-else
+if [ ! -f "$MARKER_DUMP.done" ]; then
     echo "::error::rdump.oom_dump_marker did not write a .done marker"
     exit 1
 fi
+if [ -s "$MARKER_DUMP.done" ]; then
+    echo "::error::a stale .done marker survived a dump to the same path"
+    exit 1
+fi
+echo "oom-marker OK"
 rm -rf "$MARKER_DIR"

rdump.c

@@ -611,6 +611,20 @@ static int rdump_expand_path(const char *tmpl, char *buf, size_t buf_sz)
     return 0;
 }
 
+/* Remove a stale "<dump_path>.done" before a dump is (re)written to the same
+ * path. Without this, a fixed-path dump would keep last run's marker present
+ * while the new dump is mid-write, telling a watcher the half-written file is
+ * already complete. Cleared before truncation, re-created only on success. */
+static void rdump_clear_done_marker(const char *dump_path)
+{
+    char marker[4096];
+    if ((size_t)snprintf(marker, sizeof(marker), "%s.done", dump_path)
+            >= sizeof(marker)) {
+        return;
+    }
+    unlink(marker);
+}
+
 /* Drop a "<dump_path>.done" marker once a dump is fully written and closed.
  * A directory watcher can wait for this instead of the .rdump, so it never
  * ships a half-written file -- the atomic-visibility benefit of a temp+rename
@@ -725,6 +739,13 @@ static void rdump_zend_error_cb(RDUMP_ERROR_CB_PARAMS)
                 RDUMP_G(oom_dump_count)++;
                 RDUMP_G(oom_dump_last_ts) = now;
 
+                /* Drop any prior completion marker before truncating the dump,
+                 * so a watcher never sees a stale .done over a half-rewritten
+                 * file when the same path is reused. */
+                if (RDUMP_G(oom_dump_marker)) {
+                    rdump_clear_done_marker(out_path);
+                }
+
                 char *err = NULL;
                 RDUMP_G(in_oom_dump) = 1;
                 /* Best-effort: this is the death path, so swallow any failure. */