<!-- go.dev/issue/65319 -->
The runtime now explicitly flushes trace data when a program crashes due to an
uncaught panic. This means that more complete trace data will be available in a

The [SetCrashOutput] function allows the user to specify an alternate
file to which the runtime should write its fatal crash report.
It may be used to construct an automated reporting mechanism for all
unexpected crashes, not just those in goroutines that explicitly use

		// closing it.)
		//
		// The new fd must be close-on-exec, otherwise if the
		// crash monitor is a child process, it may inherit
		// it, so it will never see EOF from the pipe even
		// when this process crashes.
		//
		// A side effect of Fd() is that it calls SetBlocking,
		// which is important so that writes of a crash report
		// to a full pipe buffer don't get lost.
		fd2, _, err := poll.DupCloseOnExec(int(f.Fd()))

/**
 * The IDE can run analysis before calling CodeGen API. We found some cases that generate different FIR expressions between analysis
 * and CodeGen API. For example, AA generates `FirLiteralExpression` for an initializer of a property, while CodeGen API generates
 * `FirLazyExpression`. The difference can result in crashes. This class helps us test the IDE situation that first calls analysis
 * APIs and conducts CodeGen.
 */

          sudo rm /var/run/secrets/istio/key.pem
          sudo chown -R istio-proxy /var/run/secrets

          # Change coredump directory to the correct user. Note this is a volume so we persist between crashes
          sudo chown -R istio-proxy:istio-proxy /var/lib/istio/data

          # place mounted bootstrap files (token is mounted directly to the correct location)

// the value the runtime attempts to maintain as the limit:
//
//	runtime.MemStats.Sys - runtime.MemStats.HeapReleased
//
// or in terms of the runtime/metrics package:
//
//	/memory/classes/total:bytes - /memory/classes/heap/released:bytes
//
// A zero limit or a limit that's lower than the amount of memory
// used by the Go runtime may cause the garbage collector to run

		log.SetFlags(0)
		log.SetPrefix("monitor: ")

		crash, err := io.ReadAll(os.Stdin)
		if err != nil {
			log.Fatalf("failed to read from input pipe: %v", err)
		}
		if len(crash) == 0 {
			// Parent process terminated without reporting a crash.
			os.Exit(0)
		}

		// Save the crash report securely in the file system.
		f, err := os.CreateTemp("", "*.crash")
		if err != nil {
			log.Fatal(err)
		}

    )

    failureConditions {
        // JavaExecDebugIntegrationTest.debug session fails without debugger might cause JVM crash
        // Some soak tests produce OOM exceptions
        // There are also random worker crashes for some tests.
        // We have test-retry to handle the crash in tests
        javaCrash = false
    }
})

private fun determineFlakyTestStrategy(stage: Stage): String {

      description: |-
        This is used to report product bugs:
        To report a security vulnerability, please visit <https://istio.io/about/security-vulnerabilities>.
        Any crashes are potentially security vulnerabilities and should be treated as such.
        To ask questions about how to use Istio, please visit <https://github.com/istio/istio/discussions>.
      options:

	"internal/trace"
	"io"
	"os"
	"runtime"
	"strings"
	"testing"
)

// TestTraceUnwindCGO verifies that trace events emitted in cgo callbacks
// produce the same stack traces and don't cause any crashes regardless of
// tracefpunwindoff being set to 0 or 1.
func TestTraceUnwindCGO(t *testing.T) {
	if *flagQuick {
		t.Skip("-quick")
	}
	testenv.MustHaveGoBuild(t)
	t.Parallel()