# BACKLOG
src/lib.rs:251 | wireshift-uring | silent-fallback | medium | REPOPULATE 2026-07-16: libc::write fails to write to eventfd, the error is quietly ignored by assigning to _, manager thread is not woken up and may deadlock or delay processing | acceptance: surface loudly by checking the return value and propagating or logging the error + a proving test asserting error propagation on write failure | status=done | FIXED (Law 10 fail-closed + ONE-PLACE): `send_manager_message` did `let written = unsafe { libc::write(wakeup_fd, ..) }; let _ = written;` - a failed wakeup left the just-queued message unprocessed (caller deadlocks on the response channel). Added a `wake_manager(wakeup_fd) -> Result<()>` helper that checks the return: 8 bytes -> Ok; the wakeup eventfd is created NONBLOCK so a `WouldBlock`/EAGAIN means the counter is already saturated (~u64::MAX pending) and the manager is guaranteed to wake -> Ok (recall-preserving, not a silent fallback); any other errno -> `Err(Error::completion("failed to wake io_uring manager via eventfd: {os_error}", ..))`. send_manager_message now sends then returns `wake_manager(..)`; the shutdown path (was a duplicate inline write at lib.rs:367) routes through the SAME helper (best-effort there). Proving tests (wake_manager_tests): wake_manager_surfaces_bad_fd_write_failure (fd -1 -> EBADF -> Err naming the failed wakeup), wake_manager_succeeds_on_valid_eventfd, wake_manager_tolerates_saturated_counter_eagain (prime counter to u64::MAX-1 so next write EAGAINs -> Ok). `cargo test -p wireshift-uring --lib` = 9 passed, EXIT=0.
src/manager.rs:246 | wireshift-uring | performance | medium | REPOPULATE 2026-07-16: shutdown blocks on fixed sleep, 10ms thread sleep is executed in a loop, delayed shutdown and unnecessary CPU thread blocking | acceptance: use non-blocking submit_and_wait with timeout or eventfd notification during shutdown + a proving test asserting shutdown completes within sub-millisecond range when no operations are pending | status=done | FIXED (Law 7): the shutdown completion wait spun on `std::thread::sleep(10ms)` up to 500 iterations. Replaced the poll-sleep loop with a single kernel-blocking `guard.ring.submitter().submit_with_args(1, &SubmitArgs::new().timespec(&5s))` - the kernel returns the instant a CQE arrives (sub-ms) or ETIME at the bounded 5s ceiling (surfaced via tracing::warn), so no CPU is burned spinning and a completion is serviced immediately instead of after the remainder of a 10ms quantum. EINTR is tolerated; other errors are warned. Proving test (tests/regression/shutdown_latency.rs, wired into regression/mod.rs): idle_backend_shutdown_completes_promptly builds a UringBackend and asserts shutdown() completes in < 100ms (skips gracefully if io_uring is unavailable, matching the existing regression guard). `cargo test -p wireshift-uring --test regression` = 3 passed (ran, not skipped - io_uring available), EXIT=0.