SIGIO      = Signal(0x16)
	SIGIOT     = Signal(0x6)
	SIGJVM1    = Signal(0x27)
	SIGJVM2    = Signal(0x28)
	SIGKILL    = Signal(0x9)
	SIGLOST    = Signal(0x25)
	SIGLWP     = Signal(0x21)
	SIGPIPE    = Signal(0xd)
	SIGPOLL    = Signal(0x16)
	SIGPROF    = Signal(0x1d)
	SIGPWR     = Signal(0x13)
	SIGQUIT    = Signal(0x3)
	SIGSEGV    = Signal(0xb)
	SIGSTOP    = Signal(0x17)
	SIGSYS     = Signal(0xc)

	}
	return int(w>>shift) & 0xFF
}

func (w WaitStatus) Signal() Signal {
	if !w.Signaled() {
		return -1
	}
	return Signal(w & mask)
}

func (w WaitStatus) StopSignal() Signal {
	if !w.Stopped() {
		return -1
	}
	return Signal(w>>shift) & 0xFF
}

func (w WaitStatus) TrapCause() int { return -1 }

// context value.
//
// If the traceback function is called from a signal handler on a Unix
// system, SigContext will be the signal context argument passed to
// the signal handler (a C ucontext_t* cast to uintptr_t). This may be
// used to start tracing at the point where the signal occurred. If
// the traceback function is not called from a signal handler,
// SigContext will be zero.
//

	start    highPrecisionTime // Time test or benchmark started
	duration time.Duration
	barrier  chan bool // To signal parallel subtests they may start. Nil when T.Parallel is not present (B) or not usable (when fuzzing).
	signal   chan bool // To signal a test is done.
	sub      []*T      // Queue of subtests to be run in parallel.

            "message": "messageValue"
          },
          "running": {
            "startedAt": "2001-01-01T01:01:01Z"
          },
          "terminated": {
            "exitCode": 1,
            "signal": 2,
            "reason": "reasonValue",
            "message": "messageValue",
            "startedAt": "2005-01-01T01:01:01Z",
            "finishedAt": "2006-01-01T01:01:01Z",

			}
		}
	}
	return infoMaps
}

// SignalServiceHandler - signal service handler.
func (s *peerRESTServer) SignalServiceHandler(vars *grid.MSS) (np grid.NoPayload, nerr *grid.RemoteErr) {
	signalString := vars.Get(peerRESTSignal)
	if signalString == "" {
		return np, grid.NewRemoteErrString("signal name is missing")
	}
	si, err := strconv.Atoi(signalString)
	if err != nil {

	g *g

	// timer is the timer used for the scavenger to sleep.
	timer *timer

	// sysmonWake signals to sysmon that it should wake the scavenger.
	sysmonWake atomic.Uint32

	// parked is whether or not the scavenger is parked.
	parked bool

	// printControllerReset instructs printScavTrace to signal that
	// the controller was reset.
	printControllerReset bool

// moveAllToActiveOrBackoffQueue moves all pods from unschedulablePods to activeQ or backoffQ.
// This function adds all pods and then signals the condition variable to ensure that
// if Pop() is waiting for an item, it receives the signal after all the pods are in the
// queue and the head is the highest priority pod.

	MOVQ	DI, runtime·lastmoduledatap(SB)
	POPQ	R15
	RET

// Initialize special registers then jump to sigpanic.
// This function is injected from the signal handler for panicking
// signals. It is quite painful to set X15 in the signal context,
// so we do it here.
TEXT ·sigpanic0(SB),NOSPLIT,$0-0
	get_tls(R14)
	MOVQ	g(R14), R14
#ifndef GOOS_plan9
	XORPS	X15, X15
#endif

		// exactly testTimeout. We give it up to one WaitDelay or one minute,
		// whichever is longer, to finish dumping stacks before we send it an
		// external signal: if the process has a lot of goroutines, dumping stacks
		// after the timeout can take a while.
		//
		// After the signal is delivered, the test process may have up to one
		// additional WaitDelay to finish writing its output streams.
		if testWaitDelay < 1*time.Minute {