Repository: microsoft/ebpf-for-windows (C)

Issue:
Workflow failed - km_mt_stress_tests_restart_extension
[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9336770229)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/05a71895566eac26a9032aac6426f58f6fa5b6de)
Test name - `km_mt_stress_tests_restart_extension`

Workflow failed - km_mt_stress_tests
[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12722566338)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d3fd4407675b77993b3e4a2a7c96f983432d532e)
Test name - `km_mt_stress_tests`



Discussion:
[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9234035167)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/10fdbbce29cb3e4d29b264e7cb4813354264de7f)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9544157177)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/197910d57b455db8756948f12eb40907b98d8e53)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9624031089)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8440c60ced5349482ab977edbc767722f721c893)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9692957249)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/4667783ba1ac04eec04abc4314490bb221cd3fd8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9730491421)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/4667783ba1ac04eec04abc4314490bb221cd3fd8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/9817788110)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c3eac3776f77666c681003eda6a4e3051717f7b6)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10004750424)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/f46db2bbc07827b20de8ccba33116600bb03f525)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10026773058)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d7942ba3dca4361da0cf118e3d7657ee8268e22a)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10055160667)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/2448139787f618901fa64b614d30a27aabb06cae)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10158568022)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/6af442038c1c84a93068134d9aac39b0d8593518)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10176468941)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/6af442038c1c84a93068134d9aac39b0d8593518)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10212213020)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/0b4142d9d674c0dc1af214aeac102e2696d8d302)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10522233286)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/6d6aad34514218c9d70aac8b4f93edd37c4735d8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10716420571)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c73a0864dd8dde9fdec7eee329ba561fc41f8681)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10734806358)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c73a0864dd8dde9fdec7eee329ba561fc41f8681)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10749865733)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/99c4e48856d53aaee6c10172ca0a5239fb306d7c)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10758271085)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/0b23bae35d86c04a28fbb7de159856d7aea768d0)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10769153812)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/be1e786c1c1256bfdb62f638cf6e2c074e69bed7)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10788384767)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/6e8f47a7c00752470e27921cfb576978b3986de4)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10807596842)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/6e8f47a7c00752470e27921cfb576978b3986de4)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10826764830)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/0396def741cbe87a8edbdb14df1c1deb9ac015ed)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10845456054)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/0396def741cbe87a8edbdb14df1c1deb9ac015ed)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10860833120)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/a41953dc623dd46d67c5863ea0de447410b35bb6)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10869372916)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/a41953dc623dd46d67c5863ea0de447410b35bb6)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10879892129)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/a41953dc623dd46d67c5863ea0de447410b35bb6)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10899046389)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/fda10838a4da5f25daa5b433f8b0dc003cf9a4f8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10918113767)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/fda10838a4da5f25daa5b433f8b0dc003cf9a4f8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10936987992)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/edcb28cd62bfee7d78df666bf0af8eb550d301fa)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10955604827)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/6ad1063766e58ced089f658f9e150a78e32d9fb1)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10970978957)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/462b8e3cab2390eb55aec81134c13ff87eb54bf0)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10979511391)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/462b8e3cab2390eb55aec81134c13ff87eb54bf0)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/10990179768)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/adb31d9d77b997d98cd7db97c5c3d56ed0764e30)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11009659346)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d712e97fd7baf62b13b6270fbdf3a78c69038d93)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11028940869)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d712e97fd7baf62b13b6270fbdf3a78c69038d93)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11048183320)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d712e97fd7baf62b13b6270fbdf3a78c69038d93)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11066946946)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/292578ef73488c0ddae393bf0e4ae38a63988395)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11082353101)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/bc299ebb07b8fcfd913226873509cc44192bb1a4)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11090986777)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/bc299ebb07b8fcfd913226873509cc44192bb1a4)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11102026053)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/e1f4ce337c9e9cd0c064b6b84cedeaa623f58089)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11121239251)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/ee6ebaf5768373cf3d27dabb23b602232d5bdfc0)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11140136719)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8743c34ab36aba305cd25603a1f3db0e3c65cc6e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11158259405)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/735ec5277f22b6e17613500ee35f5068728df1b8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11176355208)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/735ec5277f22b6e17613500ee35f5068728df1b8)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11191674757)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8250e8e88f2ad662471262713d9e8718876be423)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11200202603)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8250e8e88f2ad662471262713d9e8718876be423)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11211304882)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8250e8e88f2ad662471262713d9e8718876be423)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11231241666)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/1c383d41054778a41fb492dd2b89bd8dc7b71502)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11250828887)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/ba3f95a18295f71bc2b512d9df960a4afc580417)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11269991969)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8fb3a7e307519ac172eb2b2ca72e00dfa4593534)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11288708479)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/811c06098341961c594f872c91bf37ef78609f5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11304062344)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/811c06098341961c594f872c91bf37ef78609f5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11312703982)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/811c06098341961c594f872c91bf37ef78609f5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11323478330)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/811c06098341961c594f872c91bf37ef78609f5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11341903145)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/55b387da55c03ee600fcb8789510df037b413fdd)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11361536266)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/55b387da55c03ee600fcb8789510df037b413fdd)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11380917936)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c7b9f105085841202a28bc191409589b22caf22e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11399951513)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c7b9f105085841202a28bc191409589b22caf22e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11415926253)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c7b9f105085841202a28bc191409589b22caf22e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11424693827)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/c7b9f105085841202a28bc191409589b22caf22e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11435900401)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/14df17e1ce84108560619fdec944fd97c5415342)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11455945515)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/709cc9d8b50b84651776e4ada2c9f64b08e247ec)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11475730017)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/709cc9d8b50b84651776e4ada2c9f64b08e247ec)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11495210870)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/e5b27c3d12cb903607871d221c2c2f30bf59d80f)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/11514385668)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/e5b27c3d12cb903607871d221c2c2f30bf59d80f)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12722566338)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d3fd4407675b77993b3e4a2a7c96f983432d532e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12731758342)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/fad16491562d22ec15492f39dedc14dbed17454b)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12743022807)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/fad16491562d22ec15492f39dedc14dbed17454b)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12763493002)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9d9003c39c3fd75be5225ac0fce30077d6bf0604)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12784034827)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d3329fd7040ed3b19a1585660ff84fcf35e81d4f)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12804602886)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d3329fd7040ed3b19a1585660ff84fcf35e81d4f)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12825096479)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/149cba7e873c4e683ae2a6885972a1e917485e6f)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12842294569)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/5f890b19ec605cf0507b19e2de0038e74b7fa463)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12851707536)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/24ec3199cc20e7b84d24a416c6f66cf95103c836)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12863603242)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12882613770)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12903845640)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12924855190)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12945695557)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12963231412)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12972794634)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/95267a53b26c68a94145d1731e2a4c8b546034c3)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12984558378)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/95267a53b26c68a94145d1731e2a4c8b546034c3)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13006101893)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/07beca58c13b056abce9ba0c991f7b5d0d2d0270)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13027025842)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/07beca58c13b056abce9ba0c991f7b5d0d2d0270)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13048070161)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8efc93b9baa0f348f5799b7550bb3f8449e343d2)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13068786740)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13086724202)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13096965669)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13109007739)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13130963506)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9510332b5d2e4f223cf93b1801dcda713954b19b)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13152871988)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/56662dbb2a6151cfd60e1eeafe01d8d4742b957e)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13174419242)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/30fdb1f81aa7d4eaceb26a72d72920aeac79bebb)
Test name - `km_mt_stress_tests_restart_extension`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13195735600)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/29d9935ebb087bdb71c02ddf3023541d551f439d)
Test name - `km_mt_stress_tests_restart_extension`


[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12731758342)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/fad16491562d22ec15492f39dedc14dbed17454b)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12743022807)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/fad16491562d22ec15492f39dedc14dbed17454b)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12763493002)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9d9003c39c3fd75be5225ac0fce30077d6bf0604)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12784034827)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d3329fd7040ed3b19a1585660ff84fcf35e81d4f)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12804602886)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/d3329fd7040ed3b19a1585660ff84fcf35e81d4f)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12825096479)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/149cba7e873c4e683ae2a6885972a1e917485e6f)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12842294569)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/5f890b19ec605cf0507b19e2de0038e74b7fa463)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12851707536)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/24ec3199cc20e7b84d24a416c6f66cf95103c836)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12863603242)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12882613770)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12903845640)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12924855190)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12945695557)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12963231412)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/44f5de09ec0f3f7ad176c00a290c1cb7106cdd5e)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12972794634)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/95267a53b26c68a94145d1731e2a4c8b546034c3)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/12984558378)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/95267a53b26c68a94145d1731e2a4c8b546034c3)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13006101893)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/07beca58c13b056abce9ba0c991f7b5d0d2d0270)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13027025842)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/07beca58c13b056abce9ba0c991f7b5d0d2d0270)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13048070161)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/8efc93b9baa0f348f5799b7550bb3f8449e343d2)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13068786740)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13086724202)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13096965669)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13109007739)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9edeb98a449e7965731f814f23b720da103e7077)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13130963506)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/9510332b5d2e4f223cf93b1801dcda713954b19b)
Test name - `km_mt_stress_tests`

[Failed Run](https://github.com/microsoft/ebpf-for-windows/actions/runs/13152871988)
[Codebase](https://github.com/microsoft/ebpf-for-windows/tree/56662dbb2a6151cfd60e1eeafe01d8d4742b957e)
Test name - `km_mt_stress_tests`




Patch:
diff --git a/netebpfext/net_ebpf_ext.c b/netebpfext/net_ebpf_ext.c
index 451fb361b4..05e70e467e 100644
--- a/netebpfext/net_ebpf_ext.c
+++ b/netebpfext/net_ebpf_ext.c
@@ -34,12 +34,6 @@ static bool _net_ebpf_xdp_providers_registered = false;
 static bool _net_ebpf_bind_providers_registered = false;
 static bool _net_ebpf_sock_addr_providers_registered = false;
 static bool _net_ebpf_sock_ops_providers_registered = false;
-#if !defined(NDEBUG)
-// Global objects used to store filter contexts that are being cleaned up. This is currently only used in debug
-// contexts.
-EX_SPIN_LOCK _net_ebpf_filter_zombie_list_lock = {0};
-_Guarded_by_(_net_ebpf_filter_zombie_list_lock) static LIST_ENTRY _net_ebpf_filter_zombie_list = {0};
-#endif
 
 static net_ebpf_ext_sublayer_info_t _net_ebpf_ext_sublayers[] = {
     {&EBPF_DEFAULT_SUBLAYER, L"EBPF Sub-Layer", L"Sub-Layer for use by eBPF callouts", 0, SUBLAYER_WEIGHT_MAXIMUM},
@@ -910,10 +904,6 @@ net_ebpf_ext_register_providers()
     }
     _net_ebpf_sock_ops_providers_registered = true;
 
-#if !defined(NDEBUG)
-    InitializeListHead(&_net_ebpf_filter_zombie_list);
-#endif
-
 Exit:
     if (!NT_SUCCESS(status)) {
         net_ebpf_ext_unregister_providers();
@@ -1008,24 +998,4 @@ net_ebpf_ext_remove_client_context(
     }
 
     ExReleaseSpinLockExclusive(&filter_context->lock, old_irql);
-}
-
-#if !defined(NDEBUG)
-void
-net_ebpf_ext_add_filter_context_to_zombie_list(_Inout_ net_ebpf_extension_wfp_filter_context_t* filter_context)
-{
-    KIRQL old_irql = ExAcquireSpinLockExclusive(&_net_ebpf_filter_zombie_list_lock);
-    InsertHeadList(&_net_ebpf_filter_zombie_list, &filter_context->link);
-    ExReleaseSpinLockExclusive(&_net_ebpf_filter_zombie_list_lock, old_irql);
-}
-
-void
-net_ebpf_ext_remove_filter_context_from_zombie_list(_Inout_ net_ebpf_extension_wfp_filter_context_t* filter_context)
-{
-    if (!IsListEmpty(&filter_context->link)) {
-        KIRQL old_irql = ExAcquireSpinLockExclusive(&_net_ebpf_filter_zombie_list_lock);
-        RemoveEntryList(&filter_context->link);
-        ExReleaseSpinLockExclusive(&_net_ebpf_filter_zombie_list_lock, old_irql);
-    }
-}
-#endif
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/netebpfext/net_ebpf_ext.h b/netebpfext/net_ebpf_ext.h
index f2483026c1..7e3c716755 100644
--- a/netebpfext/net_ebpf_ext.h
+++ b/netebpfext/net_ebpf_ext.h
@@ -150,21 +150,20 @@ typedef struct _net_ebpf_extension_wfp_filter_context
 #define PRAGMA_WARNING_SUPPRESS_26100 _Pragma("warning(suppress: 26100)")
 #define PRAGMA_WARNING_POP _Pragma("warning(pop)")
 
-#define CLEAN_UP_FILTER_CONTEXT(filter_context)                                                \
-    ASSERT((filter_context) != NULL);                                                          \
-    net_ebpf_extension_hook_provider_remove_filter_context_from_zombie_list((filter_context)); \
-    if ((filter_context)->filter_ids != NULL) {                                                \
-        ExFreePool((filter_context)->filter_ids);                                              \
-    }                                                                                          \
-    PRAGMA_WARNING_PUSH                                                                        \
-    PRAGMA_WARNING_SUPPRESS_26100                                                              \
-    if ((filter_context)->client_contexts != NULL) {                                           \
-        ExFreePool((filter_context)->client_contexts);                                         \
-    }                                                                                          \
-    PRAGMA_WARNING_POP                                                                         \
-    if ((filter_context)->wfp_engine_handle != NULL) {                                         \
-        FwpmEngineClose((filter_context)->wfp_engine_handle);                                  \
-    }                                                                                          \
+#define CLEAN_UP_FILTER_CONTEXT(filter_context)               \
+    ASSERT((filter_context) != NULL);                         \
+    if ((filter_context)->filter_ids != NULL) {               \
+        ExFreePool((filter_context)->filter_ids);             \
+    }                                                         \
+    PRAGMA_WARNING_PUSH                                       \
+    PRAGMA_WARNING_SUPPRESS_26100                             \
+    if ((filter_context)->client_contexts != NULL) {          \
+        ExFreePool((filter_context)->client_contexts);        \
+    }                                                         \
+    PRAGMA_WARNING_POP                                        \
+    if ((filter_context)->wfp_engine_handle != NULL) {        \
+        FwpmEngineClose((filter_context)->wfp_engine_handle); \
+    }                                                         \
     ExFreePool((filter_context));
 
 #define REFERENCE_FILTER_CONTEXT(filter_context)                  \
@@ -389,15 +388,4 @@ net_ebpf_ext_remove_client_context(
 ebpf_result_t
 net_ebpf_ext_add_client_context(
     _Inout_ net_ebpf_extension_wfp_filter_context_t* filter_context,
-    _In_ const struct _net_ebpf_extension_hook_client* hook_client);
-
-#if !defined(NDEBUG)
-/**
- * @brief Add the filter context to the zombie list.
- *
- * @param filter_context Filter context to add to the zombie list.
- */
-void
-net_ebpf_ext_add_filter_context_to_zombie_list(_Inout_ net_ebpf_extension_wfp_filter_context_t* filter_context);
-
-#endif
+    _In_ const struct _net_ebpf_extension_hook_client* hook_client);
\ No newline at end of file
diff --git a/netebpfext/net_ebpf_ext_hook_provider.c b/netebpfext/net_ebpf_ext_hook_provider.c
index fd25bf69d4..24a994ceeb 100644
--- a/netebpfext/net_ebpf_ext_hook_provider.c
+++ b/netebpfext/net_ebpf_ext_hook_provider.c
@@ -10,6 +10,7 @@ typedef struct _net_ebpf_ext_hook_client_rundown
 {
     EX_RUNDOWN_REF protection;
     bool rundown_occurred;
+    bool rundown_initialized;
 } net_ebpf_ext_hook_rundown_t;
 
 struct _net_ebpf_extension_hook_provider;
@@ -41,9 +42,6 @@ typedef struct _net_ebpf_extension_hook_provider
     const void* custom_data; ///< Opaque pointer to hook specific data associated for this provider.
     _Guarded_by_(lock)
         LIST_ENTRY filter_context_list; ///< Linked list of filter contexts that are attached to this provider.
-    EX_PUSH_LOCK zombie_list_lock;      ///< Lock for zombie filters list.
-    _Guarded_by_(zombie_list_lock)
-        LIST_ENTRY zombie_filter_context_list; ///< Linked list of filter contexts that are attached to this provider.
 } net_ebpf_extension_hook_provider_t;
 
 typedef struct _net_ebpf_extension_invoke_programs_parameters
@@ -54,6 +52,21 @@ typedef struct _net_ebpf_extension_invoke_programs_parameters
     ebpf_result_t result;
 } net_ebpf_extension_invoke_programs_parameters_t;
 
+/**
+ * @brief Initialize the hook rundown state.
+ *
+ * @param[in, out] rundown Pointer to the rundown object to initialize.
+ */
+static void
+_ebpf_ext_init_hook_rundown(_Inout_ net_ebpf_ext_hook_rundown_t* rundown)
+{
+    ASSERT(rundown->rundown_initialized == FALSE);
+
+    ExInitializeRundownProtection(&rundown->protection);
+    rundown->rundown_occurred = FALSE;
+    rundown->rundown_initialized = TRUE;
+}
+
 /**
  * @brief Initialize the hook client rundown state.
  *
@@ -81,8 +94,7 @@ _ebpf_ext_attach_init_rundown(net_ebpf_extension_hook_client_t* hook_client)
     }
 
     // Initialize the rundown and disable new references.
-    ExInitializeRundownProtection(&rundown->protection);
-    rundown->rundown_occurred = FALSE;
+    _ebpf_ext_init_hook_rundown(rundown);
 
 Exit:
     NET_EBPF_EXT_RETURN_NTSTATUS(status);
@@ -95,10 +107,11 @@ _ebpf_ext_attach_init_rundown(net_ebpf_extension_hook_client_t* hook_client)
  *
  */
 static void
-_ebpf_ext_attach_wait_for_rundown(_Inout_ net_ebpf_ext_hook_rundown_t* rundown)
+_ebpf_ext_wait_for_rundown(_Inout_ net_ebpf_ext_hook_rundown_t* rundown)
 {
     NET_EBPF_EXT_LOG_ENTRY();
 
+    ASSERT(rundown->rundown_initialized == TRUE);
     ExWaitForRundownProtectionRelease(&rundown->protection);
     rundown->rundown_occurred = TRUE;
 
@@ -138,7 +151,7 @@ _net_ebpf_extension_detach_client_completion(_In_ DEVICE_OBJECT* device_object,
     // Issue: https://github.com/microsoft/ebpf-for-windows/issues/1854
 
     // Wait for any in progress callbacks to complete.
-    _ebpf_ext_attach_wait_for_rundown(&hook_client->rundown);
+    _ebpf_ext_wait_for_rundown(&hook_client->rundown);
 
     IoFreeWorkItem(work_item);
 
@@ -148,26 +161,42 @@ _net_ebpf_extension_detach_client_completion(_In_ DEVICE_OBJECT* device_object,
     NET_EBPF_EXT_LOG_EXIT();
 }
 
+_Must_inspect_result_ bool
+_net_ebpf_ext_enter_rundown(_Inout_ net_ebpf_ext_hook_rundown_t* rundown)
+{
+    ASSERT(rundown->rundown_initialized == TRUE);
+    return ExAcquireRundownProtection(&rundown->protection);
+}
+
+void
+_net_ebpf_ext_leave_rundown(_Inout_ net_ebpf_ext_hook_rundown_t* rundown)
+{
+    ASSERT(rundown->rundown_initialized == TRUE);
+    ExReleaseRundownProtection(&rundown->protection);
+}
+
 _Must_inspect_result_ bool
 net_ebpf_extension_hook_client_enter_rundown(_Inout_ net_ebpf_extension_hook_client_t* hook_client)
 {
-    net_ebpf_ext_hook_rundown_t* rundown = &hook_client->rundown;
-    bool status = ExAcquireRundownProtection(&rundown->protection);
-    return status;
+    return _net_ebpf_ext_enter_rundown(&hook_client->rundown);
 }
 
 void
 net_ebpf_extension_hook_client_leave_rundown(_Inout_ net_ebpf_extension_hook_client_t* hook_client)
 {
-    net_ebpf_ext_hook_rundown_t* rundown = &hook_client->rundown;
-    ExReleaseRundownProtection(&rundown->protection);
+    _net_ebpf_ext_leave_rundown(&hook_client->rundown);
+}
+
+_Must_inspect_result_ bool
+net_ebpf_extension_hook_provider_enter_rundown(_Inout_ net_ebpf_extension_hook_provider_t* provider_context)
+{
+    return _net_ebpf_ext_enter_rundown(&provider_context->rundown);
 }
 
 void
 net_ebpf_extension_hook_provider_leave_rundown(_Inout_ net_ebpf_extension_hook_provider_t* provider_context)
 {
-    net_ebpf_ext_hook_rundown_t* rundown = &provider_context->rundown;
-    ExReleaseRundownProtection(&rundown->protection);
+    _net_ebpf_ext_leave_rundown(&provider_context->rundown);
 }
 
 const ebpf_extension_data_t*
@@ -547,7 +576,7 @@ _net_ebpf_extension_hook_provider_attach_client(
 
     // No matching filter context found. Need to create a new filter context.
     // Acquire rundown reference on provider context. This will be released when the filter context is deleted.
-    rundown_acquired = ExAcquireRundownProtection(&local_provider_context->rundown.protection);
+    rundown_acquired = net_ebpf_extension_hook_provider_enter_rundown(local_provider_context);
     if (!rundown_acquired) {
         NET_EBPF_EXT_LOG_MESSAGE(
             NET_EBPF_EXT_TRACELOG_LEVEL_ERROR,
@@ -600,7 +629,7 @@ _net_ebpf_extension_hook_provider_attach_client(
 
     if (status != STATUS_SUCCESS) {
         if (rundown_acquired) {
-            ExReleaseRundownProtection(&local_provider_context->rundown.protection);
+            net_ebpf_extension_hook_provider_leave_rundown(local_provider_context);
         }
     }
 
@@ -615,10 +644,6 @@ _Requires_exclusive_lock_held_(provider_context->lock) static void _net_ebpf_ext
 
     // Remove the list entry from the provider's list of filter contexts.
     RemoveEntryList(&filter_context->link);
-    // Insert the list entry to the list of zombie filter contexts.
-    ACQUIRE_PUSH_LOCK_EXCLUSIVE(&provider_context->zombie_list_lock);
-    InsertTailList(&provider_context->zombie_filter_context_list, &filter_context->link);
-    RELEASE_PUSH_LOCK_EXCLUSIVE(&provider_context->zombie_list_lock);
 
     // Release the filter context.
     provider_context->dispatch.delete_filter_context(filter_context);
@@ -716,7 +741,7 @@ net_ebpf_extension_hook_provider_unregister(
         }
         // Wait for rundown reference to become 0. This will ensure all filter contexts, hence all
         // filter are cleaned up.
-        _ebpf_ext_attach_wait_for_rundown(&provider_context->rundown);
+        _ebpf_ext_wait_for_rundown(&provider_context->rundown);
         ExFreePool(provider_context);
     }
     NET_EBPF_EXT_LOG_EXIT();
@@ -735,6 +760,9 @@ net_ebpf_extension_hook_provider_register(
     NPI_PROVIDER_CHARACTERISTICS* characteristics;
 
     NET_EBPF_EXT_LOG_ENTRY();
+
+    *provider_context = NULL;
+
     local_provider_context = (net_ebpf_extension_hook_provider_t*)ExAllocatePoolUninitialized(
         NonPagedPoolNx, sizeof(net_ebpf_extension_hook_provider_t), NET_EBPF_EXTENSION_POOL_TAG);
     NET_EBPF_EXT_BAIL_ON_ALLOC_FAILURE_STATUS(
@@ -743,8 +771,7 @@ net_ebpf_extension_hook_provider_register(
     memset(local_provider_context, 0, sizeof(net_ebpf_extension_hook_provider_t));
     ExInitializePushLock(&local_provider_context->lock);
     InitializeListHead(&local_provider_context->filter_context_list);
-    ExInitializePushLock(&local_provider_context->zombie_list_lock);
-    InitializeListHead(&local_provider_context->zombie_filter_context_list);
+    _ebpf_ext_init_hook_rundown(&local_provider_context->rundown);
 
     characteristics = &local_provider_context->characteristics;
     characteristics->Length = sizeof(NPI_PROVIDER_CHARACTERISTICS);
@@ -771,10 +798,6 @@ net_ebpf_extension_hook_provider_register(
         goto Exit;
     }
 
-    // Initialize rundown protection for the provider context.
-    ExInitializeRundownProtection(&local_provider_context->rundown.protection);
-    local_provider_context->rundown.rundown_occurred = FALSE;
-
     *provider_context = local_provider_context;
     local_provider_context = NULL;
 
@@ -785,15 +808,3 @@ net_ebpf_extension_hook_provider_register(
 
     NET_EBPF_EXT_RETURN_NTSTATUS(status);
 }
-
-void
-net_ebpf_extension_hook_provider_remove_filter_context_from_zombie_list(
-    _Inout_ net_ebpf_extension_wfp_filter_context_t* filter_context)
-{
-    net_ebpf_extension_hook_provider_t* local_provider_context =
-        (net_ebpf_extension_hook_provider_t*)filter_context->provider_context;
-    ASSERT(local_provider_context != NULL);
-    ACQUIRE_PUSH_LOCK_EXCLUSIVE(&local_provider_context->zombie_list_lock);
-    RemoveEntryList(&filter_context->link);
-    RELEASE_PUSH_LOCK_EXCLUSIVE(&local_provider_context->zombie_list_lock);
-}
diff --git a/netebpfext/net_ebpf_ext_hook_provider.h b/netebpfext/net_ebpf_ext_hook_provider.h
index 9dd6a63dec..2319d51db5 100644
--- a/netebpfext/net_ebpf_ext_hook_provider.h
+++ b/netebpfext/net_ebpf_ext_hook_provider.h
@@ -208,12 +208,3 @@ net_ebpf_extension_hook_expand_stack_and_invoke_programs(
  */
 net_ebpf_extension_hook_attach_capability_t
 net_ebpf_extension_hook_provider_get_attach_capability(_In_ const net_ebpf_extension_hook_provider_t* provider_context);
-
-/**
- * @brief Remove the filter context from the zombie list.
- *
- * @param filter_context Filter context to remove from the zombie list.
- */
-void
-net_ebpf_extension_hook_provider_remove_filter_context_from_zombie_list(
-    _Inout_ net_ebpf_extension_wfp_filter_context_t* filter_context);


Test patch:
diff --git a/scripts/execute_ebpf_cicd_tests.ps1 b/scripts/execute_ebpf_cicd_tests.ps1
index 396072e2d2..535a0868c9 100644
--- a/scripts/execute_ebpf_cicd_tests.ps1
+++ b/scripts/execute_ebpf_cicd_tests.ps1
@@ -77,8 +77,10 @@ $Job = Start-Job -ScriptBlock {
         if ($_.CategoryInfo.Reason -eq "TimeoutException") {
             Generate-KernelDumpOnVM($TestVMName)
         }
-    }
 
+        # Throw to ensure the job is marked as failed.
+        throw $_.Exception.Message
+    }
 
     Pop-Location
 } -ArgumentList (
diff --git a/scripts/run_driver_tests.psm1 b/scripts/run_driver_tests.psm1
index 6e0ff61e2f..ae5f7c2686 100644
--- a/scripts/run_driver_tests.psm1
+++ b/scripts/run_driver_tests.psm1
@@ -292,6 +292,7 @@ function Invoke-Test
 
     Write-Log "Test `"$TestName $TestArgs`" Passed" -ForegroundColor Green
     Write-Log "`n==============================`n"
+
 }
 
 # Function to create a tuple with default values for Arguments and Timeout
@@ -451,7 +452,7 @@ function Invoke-ConnectRedirectTest
 function Invoke-CICDStressTests
 {
     param([parameter(Mandatory = $true)][bool] $VerboseLogs,
-          [parameter(Mandatory = $false)][int] $TestHangTimeout = 3600,
+          [parameter(Mandatory = $false)][int] $TestHangTimeout = (60*60),
           [parameter(Mandatory = $false)][string] $UserModeDumpFolder = "C:\Dumps",
           [parameter(Mandatory = $false)][bool] $NeedKernelDump = $true,
           [parameter(Mandatory = $false)][bool] $RestartExtension = $false)
diff --git a/tests/stress/km/stress_tests_km.cpp b/tests/stress/km/stress_tests_km.cpp
index 53a9e00edd..1dcd622670 100644
--- a/tests/stress/km/stress_tests_km.cpp
+++ b/tests/stress/km/stress_tests_km.cpp
@@ -23,6 +23,69 @@ static const std::map<std::string, test_program_attributes> _test_program_info =
       BPF_PROG_TYPE_UNSPEC,
       EBPF_EXECUTION_ANY}}};
 
+// Structure to store bpf_object_ptr elements.  A fixed-size table of these entries is shared between the 'creator',
+// 'attacher' and the 'destroyer' threads.
+struct object_table_entry
+{
+    std::unique_ptr<std::mutex> lock{nullptr};
+    _Guarded_by_(lock) bool available{true};
+    _Guarded_by_(lock) bpf_object_ptr object{nullptr};
+    _Guarded_by_(lock) bool loaded{false};
+    bool attach{false};
+
+    // The following fields are for debugging this test itself.
+    uint32_t index{0};
+    uint32_t reuse_count{0};
+    uint32_t tag{0};
+};
+
+// Possible roles for each thread. A thread is assigned a specific role at creation and it does not change thereafter.
+//
+// 'Creator' threads create as many ebpf program objects as they can, gated by the size of the object_table array.
+//
+// The 'Attacher' threads will alternatively 'attach' or 'detach' the program objects created by the 'Creator' threads
+// w/o considering if the objects have already been attached or detached.  Any errors returned by the ebpfapi are
+// ignored.
+//
+// 'Destroyer' threads close as many 'opened' eBPF program objects as then can.  These threads synchronize access to
+// the object table entries with the 'Creator' and 'Attacher' threads as the destroyer threads can only destroy program
+// objects that were created by the creator threads in the first place.
+//
+// The intent here is to cause the maximum nondeterministic multi-threaded stress scenarios as possible. Note that we
+// do not care about user mode failures in, or errors returned from, ebpfapi and focus only on exercing the in-kernel
+// eBPF components' ability to deal with such situations w/o causing a kernel hang or crash. The primary test goal here
+// is to ensure that such races do not cause hangs or crashes in the in-kernel eBPF sub-system components
+// (ebpfcore, netebpfext drivers).
+
+enum class thread_role_type : uint32_t
+{
+    ROLE_NOT_SET = 0,
+    CREATOR,
+    ATTACHER,
+    DESTROYER,
+    MONITOR_IPV4,
+    MONITOR_IPV6
+};
+
+// Context for each test thread. This is a superset and field usage varies by test.
+struct thread_context
+{
+    std::string program_name{};
+    std::string file_name{};
+    bool is_native_program{};
+    std::string map_name{};
+    thread_role_type role{};
+    uint32_t thread_index{};
+    uint32_t compartment_id{};
+    uint32_t duration_minutes{};
+    bool extension_restart_enabled{};
+    fd_t map_fd;
+    fd_t program_fd;
+    std::vector<object_table_entry>& object_table;
+    std::string extension_name{};
+    bool succeeded{true};
+};
+
 // This call is called by the common test initialization code to get a list of programs supported by the user mode
 // or kernel mode test suites. (For example, some programs could be meant for kernel mode stress testing only.)
 const std::vector<std::string>
@@ -62,7 +125,7 @@ _km_test_init()
                         _global_test_control_info.programs.begin(),
                         _global_test_control_info.programs.end(),
                         program) == _global_test_control_info.programs.end()) {
-                    LOG_INFO("ERROR: Uexpected program: {}", program);
+                    LOG_ERROR("ERROR: Uexpected program: {}", program);
                     REQUIRE(0);
                 }
             }
@@ -165,7 +228,10 @@ _restart_extension(const std::string& extension_name, uint32_t timeout)
     SC_HANDLE scm_handle = nullptr;
     SC_HANDLE service_handle = nullptr;
 
-    REQUIRE(extension_name.size() != 0);
+    if (extension_name.size() == 0) {
+        LOG_ERROR("FATAL ERROR: Extension name is empty.");
+        return false;
+    }
 
     // Get a handle to the SCM database.
     scm_handle = OpenSCManager(nullptr, nullptr, SC_MANAGER_ALL_ACCESS);
@@ -211,7 +277,10 @@ _restart_extension(const std::string& extension_name, uint32_t timeout)
 
 static std::thread
 _start_extension_restart_thread(
-    const std::string& extension_name, uint32_t restart_delay_ms, uint32_t thread_lifetime_minutes)
+    thread_context& context,
+    const std::string& extension_name,
+    uint32_t restart_delay_ms,
+    uint32_t thread_lifetime_minutes)
 {
     return std::thread(
         [&](uint32_t local_restart_delay_ms, uint32_t local_thread_lifetime_minutes) {
@@ -235,7 +304,8 @@ _start_extension_restart_thread(
                 constexpr uint32_t RESTART_TIMEOUT_SECONDS = 10;
                 LOG_VERBOSE("Toggling extension state for {} extension...", extension_name);
                 if (!_restart_extension(extension_name, RESTART_TIMEOUT_SECONDS)) {
-                    exit(-1);
+                    LOG_ERROR("FATAL ERROR: Failed to restart extension: {}", extension_name);
+                    context.succeeded = false;
                 }
 
                 LOG_VERBOSE(
@@ -248,67 +318,6 @@ _start_extension_restart_thread(
         thread_lifetime_minutes);
 }
 
-// Structure to store bpf_object_ptr elements.  A fixed-size table of these entries is shared between the 'creator',
-// 'attacher' and the 'destroyer' threads.
-struct object_table_entry
-{
-    std::unique_ptr<std::mutex> lock{nullptr};
-    _Guarded_by_(lock) bool available { true };
-    _Guarded_by_(lock) bpf_object_ptr object { nullptr };
-    _Guarded_by_(lock) bool loaded { false };
-    bool attach{false};
-
-    // The following fields are for debugging this test itself.
-    uint32_t index{0};
-    uint32_t reuse_count{0};
-    uint32_t tag{0};
-};
-
-// Possible roles for each thread. A thread is assigned a specific role at creation and it does not change thereafter.
-//
-// 'Creator' threads create as many ebpf program objects as they can, gated by the size of the object_table array.
-//
-// The 'Attacher' threads will alternatively 'attach' or 'detach' the program objects created by the 'Creator' threads
-// w/o considering if the objects have already been attached or detached.  Any errors returned by the ebpfapi are
-// ignored.
-//
-// 'Destroyer' threads close as many 'opened' eBPF program objects as then can.  These threads synchronize access to
-// the object table entries with the 'Creator' and 'Attacher' threads as the destroyer threads can only destroy program
-// objects that were created by the creator threads in the first place.
-//
-// The intent here is to cause the maximum nondeterministic multi-threaded stress scenarios as possible. Note that we
-// do not care about user mode failures in, or errors returned from, ebpfapi and focus only on exercing the in-kernel
-// eBPF components' ability to deal with such situations w/o causing a kernel hang or crash. The primary test goal here
-// is to ensure that such races do not cause hangs or crashes in the in-kernel eBPF sub-system components
-// (ebpfcore, netebpfext drivers).
-
-enum class thread_role_type : uint32_t
-{
-    ROLE_NOT_SET = 0,
-    CREATOR,
-    ATTACHER,
-    DESTROYER,
-    MONITOR_IPV4,
-    MONITOR_IPV6
-};
-
-// Context for each test thread. This is a superset and field usage varies by test.
-struct thread_context
-{
-    std::string program_name{};
-    std::string file_name{};
-    bool is_native_program{};
-    std::string map_name{};
-    thread_role_type role{};
-    uint32_t thread_index{};
-    uint32_t compartment_id{};
-    uint32_t duration_minutes{};
-    bool extension_restart_enabled{};
-    fd_t map_fd;
-    fd_t program_fd;
-    std::vector<object_table_entry>& object_table;
-};
-
 static void
 _do_creator_work(thread_context& context, std::time_t endtime_seconds)
 {
@@ -350,13 +359,13 @@ _do_creator_work(thread_context& context, std::time_t endtime_seconds)
                         }
 
                         LOG_ERROR(
-                            "(CREATOR)[{}][{}] - FATAL ERROR: bpf_object__open() failed. errno: {}",
+                            "(CREATOR)[{}][{}] - FATAL ERROR: bpf_object__open() failed for {}. errno: {}",
                             context.thread_index,
                             entry.index,
+                            context.file_name.c_str(),
                             errno);
 
-                        // We can't use a REQUIRE here as it invokes the 'catch' handler below and gives a misleading
-                        // error message.
+                        context.succeeded = false;
                         exit(-1);
                     }
 
@@ -379,10 +388,13 @@ _do_creator_work(thread_context& context, std::time_t endtime_seconds)
                     // program objects if they don't exist in the first place, so there's no point in letting the test
                     // continue execution.
                     LOG_ERROR(
-                        "(CREATOR)[{}][{}] - FATAL ERROR: Unexpected exception caught (bpf_object__open). errno: {}",
+                        "(CREATOR)[{}][{}] - FATAL ERROR: Unexpected exception caught (bpf_object__open). file: {} "
+                        "errno: {}",
                         context.thread_index,
                         entry.index,
+                        context.file_name.c_str(),
                         errno);
+                    context.succeeded = false;
                     exit(-1);
                 }
                 LOG_VERBOSE("(CREATOR)[{}][{}] - Object created.", context.thread_index, entry.index);
@@ -418,16 +430,23 @@ _do_creator_work(thread_context& context, std::time_t endtime_seconds)
 
                         if (!context.is_native_program) {
                             LOG_ERROR(
-                                "(CREATOR)[{}][{}] - FATAL ERROR: bpf_object__load() failed. result: {}, errno: {}",
+                                "(CREATOR)[{}][{}] - FATAL ERROR: bpf_object__load() failed. result: {}, errno: {} "
+                                "progname: {}",
                                 context.thread_index,
                                 entry.index,
                                 result,
-                                errno);
+                                errno,
+                                context.file_name.c_str());
 
-                            // We can't use a REQUIRE here as it invokes the 'catch' handler below and gives a
-                            // misleading error message.
+                            context.succeeded = false;
                             exit(-1);
                         }
+                    } else {
+                        LOG_VERBOSE(
+                            "(CREATOR)[{}][{}] - bpf_object__load() succeeded progname: {}",
+                            context.thread_index,
+                            entry.index,
+                            context.file_name.c_str());
                     }
                 } catch (...) {
 
@@ -442,14 +461,21 @@ _do_creator_work(thread_context& context, std::time_t endtime_seconds)
                     // program objects if they don't exist in the first place, so there's no point in letting the test
                     // continue execution.
                     LOG_ERROR(
-                        "(CREATOR)[{}][{}] - FATAL ERROR: Unexpected exception caught (bpf_object__load). errno: {}",
+                        "(CREATOR)[{}][{}] - FATAL ERROR: Unexpected exception caught (bpf_object__load). errno: {} "
+                        "filename: {}",
                         context.thread_index,
                         entry.index,
-                        errno);
+                        errno,
+                        context.file_name.c_str());
+                    context.succeeded = false;
                     exit(-1);
                 }
                 entry.loaded = true;
-                LOG_VERBOSE("(CREATOR)[{}][{}] - Object loaded.", context.thread_index, entry.index);
+                LOG_VERBOSE(
+                    "(CREATOR)[{}][{}][{}] - Object loaded.",
+                    context.thread_index,
+                    entry.index,
+                    context.file_name.c_str());
             }
         }
     }
@@ -601,9 +627,12 @@ _test_thread_function(thread_context& context)
             _do_creator_work(context, endtime_seconds);
         } else if (context.role == thread_role_type::ATTACHER) {
             _do_attacher_work(context, endtime_seconds);
-        } else {
-            REQUIRE(context.role == thread_role_type::DESTROYER);
+        } else if (context.role == thread_role_type::DESTROYER) {
             _do_destroyer_work(context, endtime_seconds);
+        } else {
+            LOG_ERROR("FATAL ERROR: Unknown thread role: {}", (uint32_t)context.role);
+            context.succeeded = false;
+            exit(-1);
         }
 
         timenow = sc::now();
@@ -618,22 +647,124 @@ _test_thread_function(thread_context& context)
         context.thread_index);
 }
 
-static _Must_inspect_result_ std::string
-_make_unique_file_copy(const std::string& file_name, uint32_t token)
+static std::string
+_generate_random_string()
+{
+    size_t string_length = 10;
+    const std::string characters = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+    std::string random_string;
+    random_string.reserve(string_length);
+    for (size_t i = 0; i < string_length; ++i) {
+        random_string += characters[rand() % characters.size()];
+    }
+
+    return random_string;
+}
+
+static std::string
+_get_unique_file_name(const std::string& file_name)
 {
     // Generate the new (unique) file name.
     std::filesystem::path file_spec = file_name;
-    std::string new_file_name = file_spec.stem().string();
-    new_file_name += (std::to_string(token) + file_spec.extension().string());
-    REQUIRE(new_file_name.size() != file_name.size());
+    return (file_spec.stem().string() + "_" + _generate_random_string() + file_spec.extension().string());
+}
+
+static _Must_inspect_result_ std::string
+_make_unique_file_copy(const std::string& file_name)
+{
+    uint32_t max_retries = 10;
+    while (max_retries--) {
+        try {
+            std::string new_file_name = _get_unique_file_name(file_name);
+            bool result =
+                std::filesystem::copy_file(file_name, new_file_name, std::filesystem::copy_options::overwrite_existing);
+            if (result) {
+                LOG_VERBOSE("Copied {} to {}", file_name, new_file_name);
+                return new_file_name;
+            } else {
+                LOG_ERROR("Failed to copy {} to {}", file_name, new_file_name);
+                if (max_retries == 0) {
+                    LOG_ERROR("Max retries exceeded.");
+                    break;
+                }
+            }
+        } catch (...) {
+            LOG_ERROR("Exception caught while copying {} to a unique file name.", file_name);
+            if (max_retries == 0) {
+                LOG_ERROR("Max retries exceeded.");
+                break;
+            }
+        }
+    }
+
+    LOG_ERROR("Failed to copy {} to a unique file name.", file_name);
+    REQUIRE(0);
+    return "";
+}
+
+static void
+configure_extension_restart(
+    const test_control_info& test_control_info,
+    const std::vector<std::string>& extension_names,
+    std::vector<std::thread>& extension_restart_thread_table,
+    std::vector<thread_context>& extension_restart_thread_context_table,
+    std::vector<object_table_entry>& object_table)
+{
+    for (uint32_t i = 0; i < extension_names.size(); i++) {
+        thread_context context_entry = {
+            {}, {}, false, {}, thread_role_type::ROLE_NOT_SET, 0, 0, 0, false, 0, 0, object_table};
+        context_entry.extension_name = extension_names[i];
+        extension_restart_thread_context_table.emplace_back(std::move(context_entry));
+
+        extension_restart_thread_table.emplace_back(std::move(_start_extension_restart_thread(
+            std::ref(extension_restart_thread_context_table.back()),
+            extension_names[i],
+            test_control_info.extension_restart_delay_ms,
+            test_control_info.duration_minutes)));
+    }
+}
+
+static void
+wait_and_verify_test_threads(
+    const test_control_info& test_control_info,
+    std::vector<std::thread>& thread_table,
+    std::vector<thread_context>& thread_context_table,
+    std::vector<std::thread>& extension_restart_thread_table,
+    std::vector<thread_context>& extension_restart_thread_context_table)
+{
+    // Wait for all test threads
+    LOG_VERBOSE("waiting on {} test threads...", thread_table.size());
+    for (auto& t : thread_table) {
+        t.join();
+    }
 
-    // Make a copy.
-    LOG_VERBOSE("Copying {} to {}", file_name, new_file_name);
-    auto result =
-        std::filesystem::copy_file(file_name, new_file_name, std::filesystem::copy_options::overwrite_existing);
-    REQUIRE(result == true);
+    // Wait for all extension restart threads
+    if (test_control_info.extension_restart_enabled) {
+        LOG_VERBOSE("waiting on {} extension restart threads...", extension_restart_thread_table.size());
+        for (auto& t : extension_restart_thread_table) {
+            t.join();
+        }
+    }
+
+    // Check if all test threads succeeded.
+    for (const auto& context : thread_context_table) {
+        if (!context.succeeded) {
+            LOG_ERROR(
+                "FATAL ERROR: Test thread failed. role: {}, index: {}", (uint32_t)context.role, context.thread_index);
+            REQUIRE(context.succeeded == true);
+        }
+    }
 
-    return new_file_name;
+    // Check if all extension restart threads succeeded.
+    if (test_control_info.extension_restart_enabled) {
+        for (const auto& context : extension_restart_thread_context_table) {
+            if (!context.succeeded) {
+                LOG_ERROR("FATAL ERROR: Extension restart thread failed. Extension: {},", context.extension_name);
+                REQUIRE(context.succeeded == true);
+            }
+        }
+    }
 }
 
 static void
@@ -658,7 +789,9 @@ _mt_prog_load_stress_test(ebpf_execution_type_t program_type, const test_control
     std::vector<std::thread> test_thread_table(total_threads);
 
     // Another table for the 'extension restart' threads (1 thread per program).
-    std::vector<std::thread> extension_restart_thread_table{};
+    std::vector<std::string> extension_names;
+    std::vector<std::thread> extension_restart_thread_table;
+    std::vector<thread_context> extension_restart_thread_context_table;
 
     // An incrementing 'compartment Id' to ensure that _each_ 'Attacher' thread gets a unique compartment id.
     uint32_t compartment_id{1};
@@ -685,8 +818,7 @@ _mt_prog_load_stress_test(ebpf_execution_type_t program_type, const test_control
                 if (test_control_info.use_unique_native_programs && context_entry.role == thread_role_type::CREATOR) {
 
                     // Create unique native programs for 'creator' threads only.
-                    context_entry.file_name =
-                        _make_unique_file_copy(program_attribs.native_file_name, (compartment_id - 1));
+                    context_entry.file_name = _make_unique_file_copy(program_attribs.native_file_name);
                 } else {
 
                     // Use the same file name for all 'creator' threads
@@ -708,27 +840,24 @@ _mt_prog_load_stress_test(ebpf_execution_type_t program_type, const test_control
         }
 
         // If requested, start the 'extension stop-and-restart' thread for extension for this program type.
-        if (test_control_info.extension_restart_enabled) {
-            auto restart_thread = _start_extension_restart_thread(
-                std::ref(program_attribs.extension_name),
-                test_control_info.extension_restart_delay_ms,
-                test_control_info.duration_minutes);
-            extension_restart_thread_table.push_back(std::move(restart_thread));
-        }
-    }
-
-    // Wait for threads to terminate.
-    LOG_INFO("waiting on {} test threads...", test_thread_table.size());
-    for (auto& t : test_thread_table) {
-        t.join();
+        extension_names.push_back(program_attribs.extension_name);
     }
 
     if (test_control_info.extension_restart_enabled) {
-        LOG_INFO("waiting on {} extension restart threads...", extension_restart_thread_table.size());
-        for (auto& t : extension_restart_thread_table) {
-            t.join();
-        }
+        configure_extension_restart(
+            test_control_info,
+            extension_names,
+            extension_restart_thread_table,
+            extension_restart_thread_context_table,
+            object_table);
     }
+
+    wait_and_verify_test_threads(
+        test_control_info,
+        test_thread_table,
+        thread_context_table,
+        extension_restart_thread_table,
+        extension_restart_thread_context_table);
 }
 
 enum class program_map_usage : uint32_t
@@ -738,10 +867,12 @@ enum class program_map_usage : uint32_t
 };
 
 static std::pair<bpf_object_ptr, fd_t>
-_load_attach_program(const std::string& file_name, enum bpf_attach_type attach_type, uint32_t thread_index)
+_load_attach_program(thread_context& context, enum bpf_attach_type attach_type)
 {
     bpf_object_ptr object_ptr;
     bpf_object* object_raw_ptr = nullptr;
+    const std::string& file_name = context.file_name;
+    const uint32_t thread_index = context.thread_index;
 
     // Get the 'object' ptr for the program associated with this thread.
     object_raw_ptr = bpf_object__open(file_name.c_str());
@@ -752,7 +883,8 @@ _load_attach_program(const std::string& file_name, enum bpf_attach_type attach_t
             thread_index,
             file_name.c_str(),
             errno);
-        REQUIRE(object_raw_ptr != nullptr);
+        context.succeeded = false;
+        return {};
     }
     LOG_VERBOSE("{}({}) Opened file:{}", __func__, thread_index, file_name.c_str());
 
@@ -760,12 +892,14 @@ _load_attach_program(const std::string& file_name, enum bpf_attach_type attach_t
     auto result = bpf_object__load(object_raw_ptr);
     if (result != 0) {
         LOG_ERROR(
-            "{}({}) FATAL ERROR: bpf_object__load({}) failed. errno:{}",
+            "{}({}) FATAL ERROR: bpf_object__load({}) failed. result:{}, errno:{}",
             __func__,
             thread_index,
             file_name.c_str(),
+            result,
             errno);
-        REQUIRE(result == 0);
+        context.succeeded = false;
+        return {};
     }
     object_ptr.reset(object_raw_ptr);
     LOG_VERBOSE("{}({}) loaded file:{}", __func__, thread_index, file_name.c_str());
@@ -779,7 +913,8 @@ _load_attach_program(const std::string& file_name, enum bpf_attach_type attach_t
             thread_index,
             file_name.c_str(),
             errno);
-        REQUIRE(program != nullptr);
+        context.succeeded = false;
+        return {};
     }
     LOG_VERBOSE(
         "{}({}) Found program object for program:{}, file_name:{}",
@@ -798,7 +933,8 @@ _load_attach_program(const std::string& file_name, enum bpf_attach_type attach_t
             file_name.c_str(),
             program->program_name,
             errno);
-        REQUIRE(program_fd >= 0);
+        context.succeeded = false;
+        return {};
     }
     LOG_VERBOSE(
         "{}({}) Opened fd:{}, for program:{}, file_name:{}",
@@ -819,7 +955,8 @@ _load_attach_program(const std::string& file_name, enum bpf_attach_type attach_t
             file_name.c_str(),
             program->program_name,
             errno);
-        REQUIRE(result == 0);
+        context.succeeded = false;
+        return {};
     }
     LOG_VERBOSE(
         "{}({}) Attached program:{}, file_name:{}", __func__, thread_index, program->program_name, file_name.c_str());
@@ -832,7 +969,11 @@ _prep_program(thread_context& context, program_map_usage map_usage)
 {
     enum bpf_attach_type attach_type =
         context.role == thread_role_type::MONITOR_IPV4 ? BPF_CGROUP_INET4_CONNECT : BPF_CGROUP_INET6_CONNECT;
-    auto [program_object, program_fd] = _load_attach_program(context.file_name, attach_type, context.thread_index);
+    auto [program_object, program_fd] = _load_attach_program(context, attach_type);
+    if (context.succeeded == false) {
+        LOG_ERROR("{}({}) - FATAL ERROR: _load_attach_program() failed.", __func__, context.thread_index);
+        exit(-1);
+    }
 
     // Stash the object pointer as we'll need it at 'close' time.
     auto& entry = context.object_table[context.thread_index];
@@ -840,10 +981,9 @@ _prep_program(thread_context& context, program_map_usage map_usage)
     context.program_fd = program_fd;
 
     if (map_usage == program_map_usage::USE_MAP) {
-
         // Get the map fd for the map for this program.
-        auto map_fd = bpf_object__find_map_fd_by_name(entry.object.get(), context.map_name.c_str());
-        if (map_fd < 0) {
+        context.map_fd = bpf_object__find_map_fd_by_name(entry.object.get(), context.map_name.c_str());
+        if (context.map_fd < 0) {
             LOG_ERROR(
                 "{}({}) FATAL ERROR: bpf_object__find_map_fd_by_name({}) failed. file_name:{}, errno:{}",
                 __func__,
@@ -851,16 +991,16 @@ _prep_program(thread_context& context, program_map_usage map_usage)
                 context.map_name.c_str(),
                 context.file_name.c_str(),
                 errno);
-            REQUIRE(map_fd >= 0);
+            context.succeeded = false;
+            exit(-1);
         }
         LOG_VERBOSE(
             "{}({}) Opened fd:{} for map:{}, file_name:{}",
             __func__,
             context.thread_index,
-            map_fd,
+            context.map_fd,
             context.map_name.c_str(),
             context.file_name.c_str());
-        context.map_fd = map_fd;
     }
 }
 
@@ -868,6 +1008,10 @@ void
 _invoke_test_thread_function(thread_context& context)
 {
     _prep_program(context, program_map_usage::USE_MAP);
+    if (context.succeeded == false) {
+        LOG_ERROR("{}({}) - FATAL ERROR: _prep_program() failed.", __func__, context.thread_index);
+        exit(-1);
+    }
     SOCKET socket_handle;
     SOCKADDR_STORAGE remote_endpoint{};
 
@@ -878,7 +1022,27 @@ _invoke_test_thread_function(thread_context& context)
         socket_handle = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
         remote_endpoint.ss_family = AF_INET6;
     }
-    REQUIRE(socket_handle != INVALID_SOCKET);
+    if (socket_handle == INVALID_SOCKET) {
+        LOG_ERROR("{}({}) - FATAL ERROR: socket() failed. errno:{}", __func__, context.thread_index, WSAGetLastError());
+        context.succeeded = false;
+        exit(-1);
+    }
+
+    // Set the timeout for connect attempts
+    timeval timeout;
+    timeout.tv_sec = 5; // 5 seconds
+    timeout.tv_usec = 0;
+    if (setsockopt(socket_handle, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout)) < 0) {
+        LOG_ERROR("{}({}) - ERROR: setsockopt() failed. errno:{}", __func__, context.thread_index, WSAGetLastError());
+        context.succeeded = false;
+        exit(-1);
+    }
+    if (setsockopt(socket_handle, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timeout, sizeof(timeout)) < 0) {
+        LOG_ERROR("{}({}) - ERROR: setsockopt() failed. errno:{}", __func__, context.thread_index, WSAGetLastError());
+        context.succeeded = false;
+        exit(-1);
+    }
+
     INETADDR_SETLOOPBACK(reinterpret_cast<PSOCKADDR>(&remote_endpoint));
     constexpr uint16_t remote_port = SOCKET_TEST_PORT;
     (reinterpret_cast<PSOCKADDR_IN>(&remote_endpoint))->sin_port = htons(remote_port);
@@ -892,13 +1056,24 @@ _invoke_test_thread_function(thread_context& context)
     // attempts as the program will not be invoked for connect attempts made while the extension is restarting.
     using sc = std::chrono::steady_clock;
     auto endtime = sc::now() + std::chrono::minutes(context.duration_minutes);
+    bool first_map_lookup = true;
     while (sc::now() < endtime) {
 
         uint16_t key = remote_port;
         uint64_t start_count = 0;
+        // Map lookup before the program invocation may fail if the program has not inserted the map entry yet.
         auto result = bpf_map_lookup_elem(context.map_fd, &key, &start_count);
-        if (start_count) {
-            REQUIRE(result == 0);
+        if (first_map_lookup) {
+            first_map_lookup = false;
+        } else if (result != 0) {
+            LOG_ERROR(
+                "{}({}) - FATAL ERROR: bpf_map_lookup_elem() failed for fd {} before connect. errno:{}",
+                __func__,
+                context.thread_index,
+                context.map_fd,
+                errno);
+            context.succeeded = false;
+            exit(-1);
         }
 
         constexpr uint32_t BURST_SIZE = 8192;
@@ -909,14 +1084,36 @@ _invoke_test_thread_function(thread_context& context)
                 socket_handle,
                 reinterpret_cast<SOCKADDR*>(&remote_endpoint),
                 static_cast<int>(sizeof(remote_endpoint)));
+
+            if (sc::now() >= endtime) {
+                break;
+            }
         }
 
         uint64_t end_count = 0;
         result = bpf_map_lookup_elem(context.map_fd, &key, &end_count);
-        REQUIRE(result == 0);
+        if (result != 0) {
+            LOG_ERROR(
+                "{}({}) - FATAL ERROR: bpf_map_lookup_elem() failed for fd {} after connect. errno:{}",
+                __func__,
+                context.thread_index,
+                context.map_fd,
+                errno);
+            context.succeeded = false;
+            exit(-1);
+        }
         LOG_VERBOSE(
             "{}({}) connect start_count:{}, end_count:{}", __func__, context.thread_index, start_count, end_count);
-        REQUIRE(end_count > start_count);
+        if (end_count <= start_count) {
+            LOG_ERROR(
+                "{}({}) - FATAL ERROR: connect count mismatched. start_count:{}, end_count:{}",
+                __func__,
+                context.thread_index,
+                start_count,
+                end_count);
+            context.succeeded = false;
+            exit(-1);
+        }
         start_count = end_count;
     }
 }
@@ -945,12 +1142,11 @@ _mt_invoke_prog_stress_test(ebpf_execution_type_t program_type, const test_contr
     std::vector<std::thread> test_thread_table(total_threads);
 
     std::vector<std::pair<std::string, std::string>> program_file_map_names = {
-        {{"cgroup_count_connect4.sys"}, {"connect4_count_map"}},
-        {{"cgroup_count_connect6.sys"}, {"connect6_count_map"}}};
+        {{_make_unique_file_copy("cgroup_count_connect4.sys")}, {"connect4_count_map"}},
+        {{_make_unique_file_copy("cgroup_count_connect6.sys")}, {"connect6_count_map"}}};
     ASSERT(program_file_map_names.size() == MAX_TCP_CONNECT_PROGRAMS);
 
     for (uint32_t i = 0; i < total_threads; i++) {
-
         // First, prepare the context for this thread.
         auto& context_entry = thread_context_table[i];
         auto& [file_name, map_name] = program_file_map_names[i];
@@ -968,29 +1164,25 @@ _mt_invoke_prog_stress_test(ebpf_execution_type_t program_type, const test_contr
         thread_entry = std::move(std::thread(_invoke_test_thread_function, std::ref(context_entry)));
     }
 
-    // Another table for the 'extension restart' threads.
-    std::vector<std::thread> extension_restart_thread_table{};
-
     // If requested, start the 'extension stop-and-restart' thread for extension for this program type.
-    std::string extension_name = {"netebpfext"};
+    std::vector<std::string> extension_names = {"netebpfext"};
+    std::vector<std::thread> extension_restart_thread_table;
+    std::vector<thread_context> extension_restart_thread_context_table;
     if (test_control_info.extension_restart_enabled) {
-        auto restart_thread = _start_extension_restart_thread(
-            std::ref(extension_name), test_control_info.extension_restart_delay_ms, test_control_info.duration_minutes);
-        extension_restart_thread_table.push_back(std::move(restart_thread));
+        configure_extension_restart(
+            test_control_info,
+            extension_names,
+            extension_restart_thread_table,
+            extension_restart_thread_context_table,
+            object_table);
     }
 
-    // Wait for threads to terminate.
-    LOG_INFO("waiting on {} test threads...", test_thread_table.size());
-    for (auto& t : test_thread_table) {
-        t.join();
-    }
-
-    if (test_control_info.extension_restart_enabled) {
-        LOG_INFO("waiting on {} extension restart threads...", extension_restart_thread_table.size());
-        for (auto& t : extension_restart_thread_table) {
-            t.join();
-        }
-    }
+    wait_and_verify_test_threads(
+        test_control_info,
+        test_thread_table,
+        thread_context_table,
+        extension_restart_thread_table,
+        extension_restart_thread_context_table);
 }
 
 static void
@@ -1006,7 +1198,11 @@ _invoke_mt_sockaddr_thread_function(thread_context& context)
         socket_handle = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
         remote_endpoint.ss_family = AF_INET6;
     }
-    REQUIRE(socket_handle != INVALID_SOCKET);
+    if (socket_handle == INVALID_SOCKET) {
+        LOG_ERROR("{}({}) - FATAL ERROR: socket() failed. errno:{}", __func__, context.thread_index, WSAGetLastError());
+        context.succeeded = false;
+        exit(-1);
+    }
     INETADDR_SETLOOPBACK(reinterpret_cast<PSOCKADDR>(&remote_endpoint));
     uint16_t remote_port = SOCKET_TEST_PORT + static_cast<uint16_t>(context.thread_index);
     (reinterpret_cast<PSOCKADDR_IN>(&remote_endpoint))->sin_port = htons(remote_port);
@@ -1042,10 +1238,13 @@ _mt_sockaddr_invoke_program_test(const test_control_info& test_control_info)
     auto error = WSAStartup(MAKEWORD(2, 2), &data);
     REQUIRE(error == 0);
 
-    auto [program_object, _] = _load_attach_program({"cgroup_mt_connect6.sys"}, BPF_CGROUP_INET6_CONNECT, 0);
-
-    // Not used, needed for thread_context initialization.
     std::vector<object_table_entry> dummy_table(1);
+    thread_context program_load_context = {
+        {}, {}, false, {}, thread_role_type::ROLE_NOT_SET, 0, 0, 0, false, 0, 0, dummy_table};
+    program_load_context.file_name = _make_unique_file_copy("cgroup_mt_connect6.sys");
+    program_load_context.thread_index = 0;
+    auto [program_object, _] = _load_attach_program(program_load_context, BPF_CGROUP_INET6_CONNECT);
+    REQUIRE(program_load_context.succeeded == true);
 
     size_t total_threads = test_control_info.threads_count;
     std::vector<thread_context> thread_context_table(
@@ -1067,28 +1266,25 @@ _mt_sockaddr_invoke_program_test(const test_control_info& test_control_info)
     }
 
     // Another table for the 'extension restart' threads.
+    std::vector<std::string> extension_names = {"netebpfext"};
     std::vector<std::thread> extension_restart_thread_table{};
+    std::vector<thread_context> extension_restart_thread_context_table{};
 
-    // If requested, start the 'extension stop-and-restart' thread for extension for this program type.
-    std::string extension_name = {"netebpfext"};
     if (test_control_info.extension_restart_enabled) {
-        auto restart_thread = _start_extension_restart_thread(
-            std::ref(extension_name), test_control_info.extension_restart_delay_ms, test_control_info.duration_minutes);
-        extension_restart_thread_table.push_back(std::move(restart_thread));
+        configure_extension_restart(
+            test_control_info,
+            extension_names,
+            extension_restart_thread_table,
+            extension_restart_thread_context_table,
+            dummy_table);
     }
 
-    // Wait for threads to terminate.
-    LOG_INFO("waiting on {} test threads...", test_thread_table.size());
-    for (auto& t : test_thread_table) {
-        t.join();
-    }
-
-    if (test_control_info.extension_restart_enabled) {
-        LOG_INFO("waiting on {} extension restart threads...", extension_restart_thread_table.size());
-        for (auto& t : extension_restart_thread_table) {
-            t.join();
-        }
-    }
+    wait_and_verify_test_threads(
+        test_control_info,
+        test_thread_table,
+        thread_context_table,
+        extension_restart_thread_table,
+        extension_restart_thread_context_table);
 }
 
 static void
@@ -1187,7 +1383,11 @@ _invoke_mt_bindmonitor_tail_call_thread_function(thread_context& context)
         for (uint32_t i = 0; i < BURST_SIZE; i++) {
             // Create a socket.
             socket_handle = WSASocket(remote_endpoint.ss_family, SOCK_STREAM, IPPROTO_TCP, nullptr, 0, 0);
-            REQUIRE(socket_handle != INVALID_SOCKET);
+            if (socket_handle == INVALID_SOCKET) {
+                LOG_ERROR("Thread[{}] WSASocket() failed. errno:{}", context.thread_index, WSAGetLastError());
+                context.succeeded = false;
+                exit(-1);
+            }
 
             INETADDR_SETANY(reinterpret_cast<PSOCKADDR>(&remote_endpoint));
             SS_PORT(&remote_endpoint) = htons(remote_port);
@@ -1204,7 +1404,8 @@ _invoke_mt_bindmonitor_tail_call_thread_function(thread_context& context)
                     WSAGetLastError(),
                     remote_port);
                 closesocket(socket_handle);
-                REQUIRE(result == 0);
+                context.succeeded = false;
+                exit(-1);
             }
 
             // Bind the socket.
@@ -1218,7 +1419,8 @@ _invoke_mt_bindmonitor_tail_call_thread_function(thread_context& context)
                     WSAGetLastError(),
                     remote_port);
                 closesocket(socket_handle);
-                REQUIRE(result == 0);
+                context.succeeded = false;
+                exit(-1);
             }
 
             LOG_VERBOSE("Thread[{}] bind success to port:{}", context.thread_index, remote_port);
@@ -1229,16 +1431,14 @@ _invoke_mt_bindmonitor_tail_call_thread_function(thread_context& context)
 }
 
 static std::pair<bpf_object_ptr, fd_t>
-_load_attach_tail_program(
-    const std::string& file_name,
-    uint32_t thread_index,
-    ebpf_attach_type_t attach_type,
-    const std::string program_name,
-    bpf_prog_type program_type)
+_load_attach_tail_program(thread_context& context, ebpf_attach_type_t attach_type, bpf_prog_type program_type)
 {
     bpf_object_ptr object_ptr;
     bpf_object* object_raw_ptr = nullptr;
     bpf_link* link = nullptr;
+    const std::string& file_name = context.file_name;
+    const std::string& program_name = context.program_name;
+    const uint32_t thread_index = context.thread_index;
 
     // Get the 'object' ptr for the program associated with this thread.
     object_raw_ptr = bpf_object__open(file_name.c_str());
@@ -1249,7 +1449,8 @@ _load_attach_tail_program(
             thread_index,
             file_name.c_str(),
             errno);
-        REQUIRE(object_raw_ptr != nullptr);
+        context.succeeded = false;
+        exit(-1);
     }
     LOG_VERBOSE("{}({}) Opened file:{}", __func__, thread_index, file_name.c_str());
 
@@ -1262,7 +1463,8 @@ _load_attach_tail_program(
             thread_index,
             file_name.c_str(),
             errno);
-        REQUIRE(result == 0);
+        context.succeeded = false;
+        exit(-1);
     }
     object_ptr.reset(object_raw_ptr);
     LOG_VERBOSE("{}({}) loaded file:{}", __func__, thread_index, file_name.c_str());
@@ -1276,7 +1478,8 @@ _load_attach_tail_program(
             thread_index,
             file_name.c_str(),
             errno);
-        REQUIRE(program != nullptr);
+        context.succeeded = false;
+        exit(-1);
     }
     LOG_VERBOSE(
         "{}({}) Found program object for program:{}, file_name:{}",
@@ -1298,7 +1501,8 @@ _load_attach_tail_program(
             file_name.c_str(),
             program->program_name,
             errno);
-        REQUIRE(program_fd >= 0);
+        context.succeeded = false;
+        exit(-1);
     }
     LOG_VERBOSE(
         "{}({}) Opened fd:{}, for program:{}, file_name:{}",
@@ -1317,7 +1521,8 @@ _load_attach_tail_program(
             file_name.c_str(),
             program->program_name,
             errno);
-        REQUIRE(result == ERROR_SUCCESS);
+        context.succeeded = false;
+        exit(-1);
     }
     LOG_VERBOSE(
         "{}({}) Attached program:{}, file_name:{}", __func__, thread_index, program->program_name, file_name.c_str());
@@ -1332,17 +1537,20 @@ _mt_bindmonitor_tail_call_invoke_program_test(const test_control_info& test_cont
     auto error = WSAStartup(MAKEWORD(2, 2), &data);
     REQUIRE(error == 0);
 
-    std::string file_name = "bindmonitor_mt_tailcall.sys";
-    std::string map_name = "bind_tail_call_map";
-    std::string program_name = "BindMonitor_Caller";
-    bpf_prog_type program_type = BPF_PROG_TYPE_BIND;
-
     // Load the program.
+    std::vector<object_table_entry> dummy_table(1);
+    thread_context program_load_context = {
+        {}, {}, false, {}, thread_role_type::ROLE_NOT_SET, 0, 0, 0, false, 0, 0, dummy_table};
+    program_load_context.program_name = "BindMonitor_Caller";
+    program_load_context.file_name = _make_unique_file_copy("bindmonitor_mt_tailcall.sys");
+    program_load_context.map_name = "bind_tail_call_map";
+    program_load_context.thread_index = 0;
     auto [program_object, _] =
-        _load_attach_tail_program(file_name, 0, EBPF_ATTACH_TYPE_BIND, program_name, program_type);
+        _load_attach_tail_program(program_load_context, EBPF_ATTACH_TYPE_BIND, BPF_PROG_TYPE_BIND);
+    REQUIRE(program_load_context.succeeded == true);
 
     // Set up the tail call programs.
-    _set_up_tailcall_program(program_object.get(), map_name);
+    _set_up_tailcall_program(program_object.get(), program_load_context.map_name);
 
     // Needed for thread_context initialization.
     constexpr uint32_t MAX_BIND_PROGRAM = 1;
@@ -1379,34 +1587,30 @@ _mt_bindmonitor_tail_call_invoke_program_test(const test_control_info& test_cont
             std::move(std::thread(_invoke_mt_bindmonitor_tail_call_thread_function, std::ref(context_entry)));
     }
 
-    // Another table for the 'extension restart' threads.
-    std::vector<std::thread> extension_restart_thread_table{};
-
     // If requested, start the 'extension stop-and-restart' thread for extension for this program type.
-    std::string extension_name = {"netebpfext"};
+    std::vector<std::string> extension_names = {"netebpfext"};
+    std::vector<std::thread> extension_restart_thread_table;
+    std::vector<thread_context> extension_restart_thread_context_table;
     if (test_control_info.extension_restart_enabled) {
-        auto restart_thread = _start_extension_restart_thread(
-            std::ref(extension_name), test_control_info.extension_restart_delay_ms, test_control_info.duration_minutes);
-        extension_restart_thread_table.push_back(std::move(restart_thread));
+        configure_extension_restart(
+            test_control_info,
+            extension_names,
+            extension_restart_thread_table,
+            extension_restart_thread_context_table,
+            object_table);
     }
 
-    // Wait for threads to terminate.
-    LOG_INFO("waiting on {} test threads...", test_thread_table.size());
-    for (auto& t : test_thread_table) {
-        t.join();
-    }
-
-    if (test_control_info.extension_restart_enabled) {
-        LOG_INFO("waiting on {} extension restart threads...", extension_restart_thread_table.size());
-        for (auto& t : extension_restart_thread_table) {
-            t.join();
-        }
-    }
+    wait_and_verify_test_threads(
+        test_control_info,
+        test_thread_table,
+        thread_context_table,
+        extension_restart_thread_table,
+        extension_restart_thread_context_table);
 
     // Clean up Winsock.
     WSACleanup();
 }
-#endif
+#endif // ENABLE_TAIL_CALL_STRESS_TEST
 
 TEST_CASE("jit_load_attach_detach_unload_random_v4_test", "[jit_mt_stress_test]")
 {
@@ -1494,9 +1698,6 @@ TEST_CASE("native_invoke_v4_v6_programs_restart_extension_test", "[native_mt_str
     LOG_INFO("\nStarting test *** native_invoke_v4_v6_programs_restart_extension_test ***");
     test_control_info local_test_control_info = _global_test_control_info;
 
-    // TODO: Bring this test in compliance with GH Issue #3223. Until then, disable extension restart for this test.
-    local_test_control_info.extension_restart_enabled = false;
-
     // This test needs only 2 threads (one per program).
     local_test_control_info.threads_count = 2;
 
@@ -1550,4 +1751,4 @@ TEST_CASE("bindmonitor_tail_call_invoke_program_test", "[native_mt_stress_test]"
     _print_test_control_info(local_test_control_info);
     _mt_bindmonitor_tail_call_invoke_program_test(local_test_control_info);
 }
-#endif
+#endif // ENABLE_TAIL_CALL_STRESS_TEST