mirror of
https://github.com/aljazceru/kata-containers.git
synced 2025-12-26 18:44:47 +01:00
1675410256
In order to reuse the same scheme across several components of the runtime repository, we need to factorize the code handling signalling through a common package. The immediate use case will be to use this package from both the CLI and the network monitor. Signed-off-by: Sebastien Boeuf <sebastien.boeuf@intel.com>
128 lines
2.8 KiB
Go
128 lines
2.8 KiB
Go
// Copyright 2018 Intel Corporation.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
package signals
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"os"
|
|
"os/signal"
|
|
"runtime/pprof"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
var signalLog = logrus.WithField("default-signal-logger", true)
|
|
|
|
// CrashOnError causes a coredump to be produced when an internal error occurs
|
|
// or a fatal signal is received.
|
|
var CrashOnError = false
|
|
|
|
// List of handled signals.
|
|
//
|
|
// The value is true if receiving the signal should be fatal.
|
|
var handledSignalsMap = map[syscall.Signal]bool{
|
|
syscall.SIGABRT: true,
|
|
syscall.SIGBUS: true,
|
|
syscall.SIGILL: true,
|
|
syscall.SIGQUIT: true,
|
|
syscall.SIGSEGV: true,
|
|
syscall.SIGSTKFLT: true,
|
|
syscall.SIGSYS: true,
|
|
syscall.SIGTRAP: true,
|
|
syscall.SIGUSR1: false,
|
|
}
|
|
|
|
// DieCb is the callback function type that needs to be defined for every call
|
|
// into the Die() function. This callback will be run as the first function of
|
|
// the Die() implementation.
|
|
type DieCb func()
|
|
|
|
// SetLogger sets the custom logger to be used by this package. If not called,
|
|
// the package will create its own logger.
|
|
func SetLogger(logger *logrus.Entry) {
|
|
signalLog = logger
|
|
}
|
|
|
|
// HandlePanic writes a message to the logger and then calls Die().
|
|
func HandlePanic(dieCb DieCb) {
|
|
r := recover()
|
|
|
|
if r != nil {
|
|
msg := fmt.Sprintf("%s", r)
|
|
signalLog.WithField("panic", msg).Error("fatal error")
|
|
|
|
Die(dieCb)
|
|
}
|
|
}
|
|
|
|
// Backtrace writes a multi-line backtrace to the logger.
|
|
func Backtrace() {
|
|
profiles := pprof.Profiles()
|
|
|
|
buf := &bytes.Buffer{}
|
|
|
|
for _, p := range profiles {
|
|
// The magic number requests a full stacktrace. See
|
|
// https://golang.org/pkg/runtime/pprof/#Profile.WriteTo.
|
|
pprof.Lookup(p.Name()).WriteTo(buf, 2)
|
|
}
|
|
|
|
for _, line := range strings.Split(buf.String(), "\n") {
|
|
signalLog.Error(line)
|
|
}
|
|
}
|
|
|
|
// FatalSignal returns true if the specified signal should cause the program
|
|
// to abort.
|
|
func FatalSignal(sig syscall.Signal) bool {
|
|
s, exists := handledSignalsMap[sig]
|
|
if !exists {
|
|
return false
|
|
}
|
|
|
|
return s
|
|
}
|
|
|
|
// NonFatalSignal returns true if the specified signal should simply cause the
|
|
// program to Backtrace() but continue running.
|
|
func NonFatalSignal(sig syscall.Signal) bool {
|
|
s, exists := handledSignalsMap[sig]
|
|
if !exists {
|
|
return false
|
|
}
|
|
|
|
return !s
|
|
}
|
|
|
|
// HandledSignals returns a list of signals the package can deal with.
|
|
func HandledSignals() []syscall.Signal {
|
|
var signals []syscall.Signal
|
|
|
|
for sig := range handledSignalsMap {
|
|
signals = append(signals, sig)
|
|
}
|
|
|
|
return signals
|
|
}
|
|
|
|
// Die causes a backtrace to be produced. If CrashOnError is set a coredump
|
|
// will be produced, else the program will exit.
|
|
func Die(dieCb DieCb) {
|
|
dieCb()
|
|
|
|
Backtrace()
|
|
|
|
if CrashOnError {
|
|
signal.Reset(syscall.SIGABRT)
|
|
syscall.Kill(0, syscall.SIGABRT)
|
|
}
|
|
|
|
os.Exit(1)
|
|
}
|