)

// Notify causes package signal to relay incoming signals to c.
// If no signals are provided, all incoming signals will be relayed to c.
// Otherwise, just the provided signals will.
//
// Package signal will not block sending to c: the caller must ensure
// that c has sufficient buffer space to keep up with the expected
// signal rate. For a channel used for notification of just one signal value,
// a buffer of size 1 is sufficient.

See the License for the specific language governing permissions and
limitations under the License.
*/

package debugger

import "syscall"

// compareSignal is the signal to trigger cache compare. For non-windows
// environment it's SIGUSR2.

// must not import anything (like net, but also like os/signal)
// that kicks off background goroutines during init.

package main

import (
	"os/signal"
	"syscall"
)

func init() {
	register("SignalIgnoreSIGTRAP", SignalIgnoreSIGTRAP)
}

func SignalIgnoreSIGTRAP() {
	signal.Ignore(syscall.SIGTRAP)
	syscall.Kill(syscall.Getpid(), syscall.SIGTRAP)
	println("OK")

	// Should die immediately, but we've seen flakiness on various
	// systems (see issue 14063). It's possible that the signal is
	// being delivered to a different thread and we are returning
	// and exiting before that thread runs again. Give the program
	// a little while to die to make sure we pick up the signal
	// before we return and exit the program. The time here
	// shouldn't matter--we'll never really sleep this long.

	/*  40 */ {_SigNotify, "signal 40"},
	/*  41 */ {_SigNotify, "signal 41"},
	/*  42 */ {_SigNotify, "signal 42"},
	/*  43 */ {_SigNotify, "signal 43"},
	/*  44 */ {_SigNotify, "signal 44"},
	/*  45 */ {_SigNotify, "signal 45"},
	/*  46 */ {_SigNotify, "signal 46"},
	/*  47 */ {_SigNotify, "signal 47"},
	/*  48 */ {_SigNotify, "signal 48"},
	/*  49 */ {_SigNotify, "signal 49"},
	/*  50 */ {_SigNotify, "signal 50"},

		}
	}
}

// signalWaitUntilIdle waits until the signal delivery mechanism is idle.
// This is used to ensure that we do not drop a signal notification due
// to a race between disabling a signal and receiving a signal.
// This assumes that signal delivery has already been disabled for
// the signal(s) in question, and here we are just waiting to make sure

}

// initializationSignalFrom returns an initialization signal function
// which when called signals that watch initialization has already finished
// to priority and fairness dispatcher.
func initializationSignalFrom(ctx context.Context) (InitializationSignal, bool) {
	signal, ok := ctx.Value(priorityAndFairnessInitializationSignalKey).(InitializationSignal)
	return signal, ok && signal != nil
}

*/

package api

import (
	"time"

	"k8s.io/apimachinery/pkg/api/resource"
)

// Signal defines a signal that can trigger eviction of pods on a node.
type Signal string

const (
	// SignalMemoryAvailable is memory available (i.e. capacity - workingSet), in bytes.
	SignalMemoryAvailable Signal = "memory.available"

// receives one of these.
//
// Note that Go installs its own signal handlers on startup, so some of these
// signals may only be received if signal handlers are changed. For example,
// SIGSEGV is normally transformed into a panic that causes the process to exit
// with status 2 if not recovered, which we handle as a crash.
func isCrashSignal(signal os.Signal) bool {
	switch signal {
	case
		syscall.SIGILL,  // illegal instruction

	/* 40 */ {_SigNotify, "signal 40"},
	/* 41 */ {_SigNotify, "signal 41"},
	/* 42 */ {_SigNotify, "signal 42"},
	/* 43 */ {_SigNotify, "signal 43"},
	/* 44 */ {_SigNotify, "signal 44"},
	/* 45 */ {_SigNotify, "signal 45"},
	/* 46 */ {_SigNotify, "signal 46"},
	/* 47 */ {_SigNotify, "signal 47"},
	/* 48 */ {_SigNotify, "signal 48"},
	/* 49 */ {_SigNotify, "signal 49"},
	/* 50 */ {_SigNotify, "signal 50"},