mirror of
https://github.com/tailscale/tailscale.git
synced 2026-11-20 08:41:19 -08:00
Monitor teardown SIGHUPed and SIGKILLed every remembered child group when the transport closed. sshd signals nothing at a non-PTY session end; background jobs with redirected stdio survive and reparent to init. Clients rely on that: VS Code Remote-SSH starts its remote server as a plain background job in the session's group and expects it to outlive connection drops, and tailscale upgrades run as non-PTY execs whose work should survive a daemon restart. Now only SSHTerminationError causes (revocation, session-duration, recording failure) kill the process tree. Everything else — client disconnect, daemon shutdown — closes I/O without signals: PTY masters close and the driver SIGHUPs the foreground group, non-PTY processes exit on EOF and SIGPIPE or keep running. Monitor teardown kills only forwarding children, unless revocation armed the new kill-all op first, since its per-session kicks race the close. No zombie leak: the monitor reaps its table, and reparented survivors are reaped by init. Fixes #22076 Signed-off-by: James Tucker <[email protected]> Change-Id: I70b4ef40035330dd542d256ba79d889a12426a74
162 lines
4.7 KiB
Go
162 lines
4.7 KiB
Go
// Copyright (c) Tailscale Inc & contributors
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
//go:build (linux && !android) || (darwin && !ios) || freebsd || openbsd
|
|
|
|
// Session processes are launched by the connection's privileged monitor.
|
|
// tailscaled keeps the parent I/O descriptors and passes the child's stdio
|
|
// and optional environment pipe via SCM_RIGHTS.
|
|
|
|
package tailssh
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// hangupEscalation is the delay between SIGHUP and SIGKILL on session teardown.
|
|
const hangupEscalation = 5 * time.Second
|
|
|
|
// monExitRegistry matches exit notifications to child handles, including
|
|
// notifications received before the session registers its waiter.
|
|
type monExitRegistry struct {
|
|
mu sync.Mutex
|
|
waiters map[monitorProcess]*monExitStatus
|
|
pending map[monitorProcess]int // exits received before registration
|
|
}
|
|
|
|
// dispatchExit is the monitorClient exit callback, called from the
|
|
// client's read-loop goroutine.
|
|
func (s *monExitRegistry) dispatchExit(pid monitorProcess, code int) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if ch, ok := s.waiters[pid]; ok {
|
|
delete(s.waiters, pid)
|
|
ch.complete(code)
|
|
return
|
|
}
|
|
if s.pending == nil {
|
|
s.pending = make(map[monitorProcess]int)
|
|
}
|
|
s.pending[pid] = code
|
|
}
|
|
|
|
// registerSessionExit delivers and removes a pending exit, or registers
|
|
// a waiter for a future notification.
|
|
func (s *monExitRegistry) registerSessionExit(pid monitorProcess, ch *monExitStatus) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if code, ok := s.pending[pid]; ok {
|
|
delete(s.pending, pid)
|
|
ch.complete(code)
|
|
return
|
|
}
|
|
if s.waiters == nil {
|
|
s.waiters = make(map[monitorProcess]*monExitStatus)
|
|
}
|
|
s.waiters[pid] = ch
|
|
}
|
|
|
|
func newMonExitStatus() *monExitStatus {
|
|
return &monExitStatus{done: make(chan struct{})}
|
|
}
|
|
|
|
func (s *monExitStatus) complete(code int) {
|
|
s.code = code
|
|
close(s.done)
|
|
}
|
|
|
|
// launchViaMonitor passes cmd and the child's descriptors to the monitor.
|
|
// After dispatch, cancellation does not abandon the exec reply: a successful
|
|
// launch always registers the child so run can terminate it and wait for exit.
|
|
func (ss *sshSession) launchViaMonitor(cmd *exec.Cmd, envFile *os.File, stdio []*os.File, ctty bool) error {
|
|
if len(stdio) != 3 {
|
|
return fmt.Errorf("internal error: monitor exec needs 3 stdio fds, got %d", len(stdio))
|
|
}
|
|
if err := ss.ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
mc, err := ss.conn.connMonitor()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
child, err := mc.ExecIncubator(ss.ctx, cmd.Args, cmd.Env, cmd.Dir, ctty, envFile, stdio...)
|
|
if err != nil {
|
|
return fmt.Errorf("exec on session monitor: %w", err)
|
|
}
|
|
exit := newMonExitStatus()
|
|
ss.conn.monitor.exits.registerSessionExit(child, exit)
|
|
ss.monChild = child
|
|
ss.monExit = exit
|
|
ss.monDead = mc.Gone()
|
|
return nil
|
|
}
|
|
|
|
// waitMonitorProcess returns the child's exit code, or an error if its monitor
|
|
// dies without reporting an exit. ok is false for directly launched sessions.
|
|
func (ss *sshSession) waitMonitorProcess() (code int, ok bool, err error) {
|
|
if ss.monExit == nil {
|
|
return 0, false, nil
|
|
}
|
|
select {
|
|
case <-ss.monExit.done:
|
|
return ss.monExit.code, true, nil
|
|
case <-ss.monDead:
|
|
// The read loop delivers notifications before closing monDead.
|
|
// Recheck here because both cases may have become ready together.
|
|
select {
|
|
case <-ss.monExit.done:
|
|
return ss.monExit.code, true, nil
|
|
default:
|
|
return 1, true, errors.New("session monitor exited before the session process")
|
|
}
|
|
}
|
|
}
|
|
|
|
// hangupMonitorProcess sends SIGHUP to the session process group and
|
|
// schedules the SIGKILL escalation when mandated is true, and does
|
|
// nothing when it is false. See hangupProcess. Returns false for
|
|
// directly launched sessions.
|
|
func (ss *sshSession) hangupMonitorProcess(mandated bool) bool {
|
|
if ss.monChild.PID == 0 {
|
|
return false
|
|
}
|
|
mc := ss.conn.connMonitorIfAny()
|
|
if mc == nil {
|
|
// Monitor teardown owns cleanup. Its reaped PIDs may already have
|
|
// been reused, so tailscaled must not signal them directly.
|
|
return true
|
|
}
|
|
if !mandated {
|
|
// Not mandated, so do not signal.
|
|
return true
|
|
}
|
|
if ss.ptyReq == nil {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := mc.Signal(ctx, ss.monChild, "SIGHUP"); err != nil {
|
|
ss.logf("ssh: SIGHUP session process group: %v", err)
|
|
}
|
|
}
|
|
time.AfterFunc(knobDuration(sshHupEscalation(), hangupEscalation), func() { ss.escalateMonitorProcess(mc) })
|
|
return true
|
|
}
|
|
|
|
func (ss *sshSession) escalateMonitorProcess(mc *monitorClient) {
|
|
select {
|
|
case <-ss.monExit.done:
|
|
return
|
|
default:
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := mc.Signal(ctx, ss.monChild, "SIGKILL"); err != nil {
|
|
ss.vlogf("ssh: SIGKILL session process group: %v", err)
|
|
}
|
|
}
|