Add death test for stack-overflow exception filter path

Summary:
D116557659 made `windowsExceptionFilter` stack-overflow-safe: for
EXCEPTION_STACK_OVERFLOW it skips DbgHelp symbolization (which double-faults
on the exhausted stack), writes one static message to stderr, and returns
EXCEPTION_CONTINUE_SEARCH so the OS default handling reaches WER and writes
the LocalDumps minidump. That is what gives us crash dumps for the
ProjFS-drop SEV (S697276, T284863536).

This adds a gtest death test that locks in the guarantee that stack
overflows reach WER. The death-test child installs the real exception filter
and drives a real stack overflow via noinline recursion with a 4KB volatile
frame (so the optimizer cannot inline, collapse, or tail-call it). It
asserts both discriminating behaviors of the fix:

- the child's exit status is STATUS_STACK_OVERFLOW (0xC00000FD), i.e. the
  exception code propagated through EXCEPTION_CONTINUE_SEARCH to the OS
  default handling, and
- stderr contains "stack overflow detected, deferring to WER for crash
  dump", the filter's no-stack static message.

Against the pre-fix filter the child instead dies of the filter's own
access violation (exit 0xC0000005) without writing the message, so this
test fails against the old code (verified below).

The gtest exit-code predicate compares the unsigned representation because
gtest reports the raw Windows exit status as a signed int, making
0xC00000FD appear negative.

The BUCK target is gated to Windows with `compatible_with`. For
`network_access` (required by BUCKLINT's network_access_required), the
network_access_utils helpers cannot be used directly: they all resolve to
"all" on non-Linux, and the Windows RE test platform rejects unisolated
tests (NetworkIsolationType::NONE is not in its allow-list). Instead the
target uses a select that isolates on Linux and leaves network_access
unset on Windows so the platform default isolation applies - the same
pattern as buck2/tests/meta_only/e2e/targets/cross_os_tests. This test
needs no network.

Differential Revision: D116566143

fbshipit-source-id: aca3415eb61bda498a3af02a7683189ba2e6c3bb

Author: MichaelCuevas

eden/fs/utils/test/BUCK

@@ -189,6 +189,29 @@ cpp_unittest(
     ],
 )
 
+cpp_unittest(
+    name = "win_stacktrace_test",
+    srcs = ["WinStackTraceTest.cpp"],
+    compatible_with = [
+        "ovr_config//os:windows",
+    ],
+    # The network_access_utils helpers resolve to "all" on non-Linux, which
+    # the Windows RE test platform rejects (only restricted isolation modes
+    # and the platform default are allowed). Leave network_access unset on
+    # Windows so the platform default isolation applies; this test needs no
+    # network. Same pattern as buck2/tests/meta_only/e2e/targets/cross_os_tests.
+    network_access = select({
+        "DEFAULT": None,
+        "ovr_config//os:linux": network_access_utils.NETWORK_ACCESS_NONE,
+    }),
+    supports_static_listing = False,
+    deps = [
+        "//eden/fs/utils:win_stacktrace",
+        "//folly:c_portability",
+        "//folly/portability:gtest",
+    ],
+)
+
 cpp_benchmark(
     name = "bench",
     srcs = [

eden/fs/utils/test/WinStackTraceTest.cpp

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This software may be used and distributed according to the terms of the
+ * GNU General Public License version 2.
+ */
+
+#include "eden/fs/utils/WinStackTrace.h"
+
+#ifdef _WIN32
+#include <cstdint>
+#include <cstdio>
+
+#include <folly/CPortability.h>
+#include <folly/portability/GTest.h>
+
+namespace {
+
+// Recurse with a sizable frame that the optimizer cannot collapse:
+// FOLLY_NOINLINE prevents inlining, the volatile buffer forces a real stack
+// allocation in every frame, and using the recursive result after the call
+// prevents tail-call optimization. The depth bound keeps this from being
+// recursion on all control paths (which MSVC rejects with C4717) while still
+// being effectively infinite: the stack overflows long before it is reached.
+FOLLY_NOINLINE int overflowTheStack(int depth) {
+  volatile char buffer[4096];
+  buffer[0] = static_cast<char>(depth);
+  buffer[sizeof(buffer) - 1] = buffer[0];
+  if (depth < 100000000) {
+    return overflowTheStack(depth + 1) + buffer[sizeof(buffer) - 1];
+  }
+  return buffer[0];
+}
+
+bool exitedWithStackOverflow(int exitCode) {
+  // gtest reports the raw Windows exit status as an int, so
+  // STATUS_STACK_OVERFLOW (0xC00000FD) appears as a negative value; compare
+  // the unsigned representation.
+  if (static_cast<uint32_t>(exitCode) != 0xC00000FDu) {
+    fprintf(
+        stderr,
+        "unexpected exit code: 0x%X\n",
+        static_cast<unsigned int>(exitCode));
+    return false;
+  }
+  return true;
+}
+
+} // namespace
+
+TEST(WinStackTraceTest, stackOverflowDefersToWer) {
+  // The death-test child installs the real exception filter and drives a
+  // real stack overflow. The filter must not symbolize on the exhausted
+  // stack: it writes one static message to stderr and returns
+  // EXCEPTION_CONTINUE_SEARCH, so the OS default handling (WER) terminates
+  // the child with STATUS_STACK_OVERFLOW as the exit status. If the filter
+  // regresses to symbolizing (or holding large locals in its own frame), it
+  // double-faults before writing anything and this test fails on the missing
+  // stderr message.
+  EXPECT_EXIT(
+      {
+        facebook::eden::installWindowsExceptionFilter();
+        overflowTheStack(0);
+      },
+      exitedWithStackOverflow,
+      "stack overflow detected, deferring to WER for crash dump");
+}
+#endif