expected: "blub blix",
			},
			{
				mode: "panics",
				musthave: []string{
					"fatal error: exit hook invoked panic",
					"main.testPanics",
				},
			},
			{
				mode: "callsexit",
				musthave: []string{
					"fatal error: exit hook invoked exit",
				},
			},
			{
				mode:     "exit2",
				expected: "",
			},
		}

		exe, err := buildTestProg(t, "testexithooks", bmode)
		if err != nil {

	f2 := func() { os.Exit(1) }
	f3 := func() { println("good") }
	exithook.Add(exithook.Hook{F: f1, RunOnFailure: true})
	exithook.Add(exithook.Hook{F: f2, RunOnFailure: true})
	exithook.Add(exithook.Hook{F: f3, RunOnFailure: true})
	os.Exit(1)
}

func testExit2() {
	f1 := func() { time.Sleep(100 * time.Millisecond) }
	exithook.Add(exithook.Hook{F: f1})
	for range 10 {
		go os.Exit(0)
	}
	os.Exit(0)

import (
	"sync"
	_ "unsafe" // for linkname
)

// PanicOnExit0 reports whether to panic on a call to os.Exit(0).
// This is in the testlog package because, like other definitions in
// package testlog, it is a hook between the testing package and the
// os package. This is used to ensure that an early call to os.Exit(0)
// does not cause a test to pass.
func PanicOnExit0() bool {
	panicOnExit0.mu.Lock()
	defer panicOnExit0.mu.Unlock()

		// We can't safely sigpanic because it may grow the
		// stack. Abort in the signal handler instead.
		flags = (flags &^ _SigPanic) | _SigThrow
	}
	if flags&_SigGoExit != 0 {
		exits((*byte)(add(unsafe.Pointer(note), 9))) // Strip "go: exit " prefix.
	}
	if flags&_SigPanic != 0 {
		// Copy the error string from sigtramp's stack into m->notesig so
		// we can reliably access it from the panic routines.

}

// Run starts the envoy and waits until it terminates.
// There are a few exit paths:
//  1. Envoy exits. In this case, we simply log and exit.
//  2. /quitquitquit (on agent, not Envoy) is called. We will set skipDrain and cancel the context, which triggers us to exit immediately.
//  3. SIGTERM. We will drain, wait termination drain duration, then exit. This is the standard pod shutdown; SIGTERM arrives when pod shutdown starts.

		APICode: "kms:KeyAlreadyExists",
		Err:     "key with given key ID already exits",
	}

	// ErrKeyNotFound is an error returned by the KMS when trying to
	// use a key that does not exist.
	ErrKeyNotFound = Error{
		Code:    http.StatusNotFound,
		APICode: "kms:KeyNotFound",
		Err:     "key with given key ID does not exit",
	}

	// ErrDecrypt is an error returned by the KMS when the decryption

          pid="$$$$"

          # Run the pilot agent and Envoy
          # TODO: run with systemctl?
          # Setup a script to start istio but exit the container if it exits. This more closely mirrors Pods.
          # This is not strictly needed, but it makes our CI properly report crashes (including core dumps)
          cat <<'EOF'>/tmp/start.sh
          #!/bin/bash

func corostart() {
	gp := getg()
	c := gp.coroarg
	gp.coroarg = nil

	defer coroexit(c)
	c.f(c)
}

// coroexit is like coroswitch but closes the coro
// and exits the current goroutine
func coroexit(c *coro) {
	gp := getg()
	gp.coroarg = c
	gp.coroexit = true
	mcall(coroswitch_m)
}

//go:linkname coroswitch

// coroswitch switches to the goroutine blocked on c

)

func handleSignals() {
	// Custom exit function
	exit := func(success bool) {
		if globalLoggerOutput != nil {
			globalLoggerOutput.Close()
		}

		// If global profiler is set stop before we exit.
		globalProfilerMu.Lock()
		defer globalProfilerMu.Unlock()
		for _, p := range globalProfiler {
			p.Stop()
		}

		if success {
			os.Exit(0)
		}

		os.Exit(1)
	}

	stopProcess := func() bool {

)

// Add adds a new exit hook.
func Add(h Hook) {
	for !locked.CompareAndSwap(0, 1) {
		Gosched()
	}
	hooks = append(hooks, h)
	locked.Store(0)
}

// Run runs the exit hooks.
//
// If an exit hook panics, Run will throw with the panic on the stack.
// If an exit hook invokes exit in the same goroutine, the goroutine will throw.
// If an exit hook invokes exit in another goroutine, that exit will block.