From d02b74a5dcfed4bfc8f2f8e545bca4d2afabb296 Mon Sep 17 00:00:00 2001 From: Googler Date: Fri, 27 Apr 2018 10:37:02 -0700 Subject: Check in gVisor. PiperOrigin-RevId: 194583126 Change-Id: Ica1d8821a90f74e7e745962d71801c598c652463 --- pkg/sentry/sighandling/BUILD | 18 +++++ pkg/sentry/sighandling/sighandling.go | 116 +++++++++++++++++++++++++++ pkg/sentry/sighandling/sighandling_unsafe.go | 74 +++++++++++++++++ 3 files changed, 208 insertions(+) create mode 100644 pkg/sentry/sighandling/BUILD create mode 100644 pkg/sentry/sighandling/sighandling.go create mode 100644 pkg/sentry/sighandling/sighandling_unsafe.go (limited to 'pkg/sentry/sighandling') diff --git a/pkg/sentry/sighandling/BUILD b/pkg/sentry/sighandling/BUILD new file mode 100644 index 000000000..daaad7c90 --- /dev/null +++ b/pkg/sentry/sighandling/BUILD @@ -0,0 +1,18 @@ +package(licenses = ["notice"]) # Apache 2.0 + +load("@io_bazel_rules_go//go:def.bzl", "go_library") + +go_library( + name = "sighandling", + srcs = [ + "sighandling.go", + "sighandling_unsafe.go", + ], + importpath = "gvisor.googlesource.com/gvisor/pkg/sentry/sighandling", + visibility = ["//pkg/sentry:internal"], + deps = [ + "//pkg/abi/linux", + "//pkg/sentry/arch", + "//pkg/sentry/kernel", + ], +) diff --git a/pkg/sentry/sighandling/sighandling.go b/pkg/sentry/sighandling/sighandling.go new file mode 100644 index 000000000..1a94b535b --- /dev/null +++ b/pkg/sentry/sighandling/sighandling.go @@ -0,0 +1,116 @@ +// Copyright 2018 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package sighandling contains helpers for handling signals to applications. +package sighandling + +import ( + "os" + "os/signal" + "reflect" + "syscall" + + "gvisor.googlesource.com/gvisor/pkg/abi/linux" + "gvisor.googlesource.com/gvisor/pkg/sentry/arch" + "gvisor.googlesource.com/gvisor/pkg/sentry/kernel" +) + +// numSignals is the number of normal (non-realtime) signals on Linux. +const numSignals = 32 + +// forwardSignals listens for incoming signals and delivers them to k. It stops +// when the stop channel is closed. +func forwardSignals(k *kernel.Kernel, sigchans []chan os.Signal, stop chan struct{}) { + // Build a select case. + sc := []reflect.SelectCase{{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(stop)}} + for _, sigchan := range sigchans { + sc = append(sc, reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(sigchan)}) + } + + for { + // Wait for a notification. + index, _, ok := reflect.Select(sc) + + // Was it the stop channel? + if index == 0 { + if !ok { + break + } + continue + } + + // How about a different close? + if !ok { + panic("signal channel closed unexpectedly") + } + + // Otherwise, it was a signal on channel N. Index 0 represents the stop + // channel, so index N represents the channel for signal N. + if !k.SendExternalSignal(&arch.SignalInfo{Signo: int32(index)}, "sentry") { + // Kernel is not ready to receive signals. + // + // Kill ourselves if this signal would have killed the + // process before StartForwarding was called. i.e., all + // _SigKill signals; see Go + // src/runtime/sigtab_linux_generic.go. + // + // Otherwise ignore the signal. + // + // TODO: Convert Go's runtime.raise from + // tkill to tgkill so StartForwarding doesn't need to + // be called until after filter installation. + switch linux.Signal(index) { + case linux.SIGHUP, linux.SIGINT, linux.SIGTERM: + dieFromSignal(linux.Signal(index)) + } + } + } + + // Close all individual channels. + for _, sigchan := range sigchans { + signal.Stop(sigchan) + close(sigchan) + } +} + +// StartForwarding ensures that synchronous signals are forwarded to k and +// returns a callback that stops signal forwarding. +func StartForwarding(k *kernel.Kernel) func() { + stop := make(chan struct{}) + + // Register individual channels. One channel per standard signal is + // required as os.Notify() is non-blocking and may drop signals. To avoid + // this, standard signals have to be queued separately. Channel size 1 is + // enough for standard signals as their semantics allow de-duplication. + // + // External real-time signals are not supported. We rely on the go-runtime + // for their handling. + var sigchans []chan os.Signal + for sig := 1; sig <= numSignals+1; sig++ { + sigchan := make(chan os.Signal, 1) + sigchans = append(sigchans, sigchan) + + // SignalPanic is handled by Run. + if linux.Signal(sig) == kernel.SignalPanic { + continue + } + + signal.Notify(sigchan, syscall.Signal(sig)) + } + // Start up our listener. + go forwardSignals(k, sigchans, stop) // S/R-SAFE: synchronized by Kernel.extMu + + // ... shouldn't this wait until the forwardSignals goroutine returns? + return func() { close(stop) } +} diff --git a/pkg/sentry/sighandling/sighandling_unsafe.go b/pkg/sentry/sighandling/sighandling_unsafe.go new file mode 100644 index 000000000..a455b919f --- /dev/null +++ b/pkg/sentry/sighandling/sighandling_unsafe.go @@ -0,0 +1,74 @@ +// Copyright 2018 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package sighandling + +import ( + "fmt" + "runtime" + "syscall" + "unsafe" + + "gvisor.googlesource.com/gvisor/pkg/abi/linux" +) + +// TODO: Move to pkg/abi/linux along with definitions in +// pkg/sentry/arch. +type sigaction struct { + handler uintptr + flags uint64 + restorer uintptr + mask uint64 +} + +// IgnoreChildStop sets the SA_NOCLDSTOP flag, causing child processes to not +// generate SIGCHLD when they stop. +func IgnoreChildStop() error { + var sa sigaction + + // Get the existing signal handler information, and set the flag. + if _, _, e := syscall.RawSyscall6(syscall.SYS_RT_SIGACTION, uintptr(syscall.SIGCHLD), 0, uintptr(unsafe.Pointer(&sa)), linux.SignalSetSize, 0, 0); e != 0 { + return e + } + sa.flags |= linux.SA_NOCLDSTOP + if _, _, e := syscall.RawSyscall6(syscall.SYS_RT_SIGACTION, uintptr(syscall.SIGCHLD), uintptr(unsafe.Pointer(&sa)), 0, linux.SignalSetSize, 0, 0); e != 0 { + return e + } + + return nil +} + +// dieFromSignal kills the current process with sig. +// +// Preconditions: The default action of sig is termination. +func dieFromSignal(sig linux.Signal) { + runtime.LockOSThread() + defer runtime.UnlockOSThread() + + sa := sigaction{handler: linux.SIG_DFL} + if _, _, e := syscall.RawSyscall6(syscall.SYS_RT_SIGACTION, uintptr(sig), uintptr(unsafe.Pointer(&sa)), 0, linux.SignalSetSize, 0, 0); e != 0 { + panic(fmt.Sprintf("rt_sigaction failed: %v", e)) + } + + set := linux.MakeSignalSet(sig) + if _, _, e := syscall.RawSyscall6(syscall.SYS_RT_SIGPROCMASK, linux.SIG_UNBLOCK, uintptr(unsafe.Pointer(&set)), 0, linux.SignalSetSize, 0, 0); e != 0 { + panic(fmt.Sprintf("rt_sigprocmask failed: %v", e)) + } + + if err := syscall.Tgkill(syscall.Getpid(), syscall.Gettid(), syscall.Signal(sig)); err != nil { + panic(fmt.Sprintf("tgkill failed: %v", err)) + } + + panic("failed to die") +} -- cgit v1.2.3