*/

package runtime

/*
#define __DARWIN_UNIX03 0
#include <mach/mach_time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <errno.h>
#include <signal.h>
#include <sys/event.h>
#include <sys/mman.h>
#include <pthread.h>
#include <fcntl.h>
*/
import "C"

const (
	EINTR     = C.EINTR
	EFAULT    = C.EFAULT
	EAGAIN    = C.EAGAIN

	/*  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"

	/* 56 */ {_SigNotify, "real time signal"},
	/* 57 */ {_SigNotify, "real time signal"},
	/* 58 */ {_SigNotify, "real time signal"},
	/* 59 */ {_SigNotify, "real time signal"},
	/* 60 */ {_SigNotify, "real time signal"},
	/* 61 */ {_SigNotify, "real time signal"},
	/* 62 */ {_SigNotify, "real time signal"},
	/* 63 */ {_SigNotify, "real time signal"},
	/* 64 */ {_SigNotify, "real time signal"},
	/* 65 */ {_SigNotify, "real time signal"},

import (
	"fmt"
	"os"
	"os/signal"
)

func ExampleNotify() {
	// Set up channel on which to send signal notifications.
	// We must use a buffered channel or risk missing the signal
	// if we're not ready to receive when the signal is sent.
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)

	// Block until a signal is received.
	s := <-c
	fmt.Println("Got signal:", s)
}

	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"},
	51:          {_SigNotify, "signal 51"},
	52:          {_SigNotify, "signal 52"},

// 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

		flags = sigtable[sig].flags
	}

	// If the signal is ignored, raising the signal is no-op.
	if handler == _SIG_IGN || (handler == _SIG_DFL && flags&_SigIgn != 0) {
		return
	}

	// Reset the signal handler and raise the signal.
	// We are currently running inside a signal handler, so the
	// signal is blocked. We need to unblock it before raising the
	// signal, or the signal we raise will be ignored until we return