终端关闭时终止 sudo python 脚本

Question

如何判断终端 运行ning 我的 python 脚本是否已关闭？如果用户关闭终端，我想安全地结束我的 python 脚本。我可以使用处理程序捕获 SIGHUP，但当脚本为 运行 作为 sudo 时则无法捕获。当我用 sudo 启动脚本并关闭终端时，python 脚本保持 运行ning.

示例脚本：

import signal
import time
import sys

def handler(signum, frame):
    fd = open ("tmp.txt", "a")
    fd.write(str(signum) + " handled\n")
    fd.close()
    sys.exit(0)


signal.signal(signal.SIGHUP, handler)
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)

time.sleep(50)

有时脚本会在 运行 时作为 sudo 执行处理程序，但更多时候不会。当 运行 没有 sudo 时，脚本总是写入文件。我 运行 在 Raspberry Pi 上使用它。我在 LXTerminal 和 gnome-terminal 中看到同样的事情。此示例脚本将在 50 秒后结束，但我的冗长代码 运行s 处于无限循环中

最终目标是在 Raspberry Pi 上安装一个 .desktop 启动器来进行蓝牙扫描和查找设备。蓝牙扫描需要 sudo 因为它使用 4.0 BLE。我不确定为什么 bluez 需要 sudo 但确实如此。在 pi 上键入 sudo 时，它从不要求输入密码，这对我来说没问题。问题是关闭终端后，扫描过程还在运行ning。扫描由终端中 运行 的 python 脚本完成。

Answer 1

sudo 是为您在 tty 上的某个其他进程的 child 时获得的 SIGHUP 语义而设计的。在这种情况下，当 parent 退出时，所有进程都会从内核获得自己的 SIGHUP。

xterm -e sudo cmd 运行s sudo 直接上pseudo-terminal。这会产生与 sudo 预期不同的 SIGHUP 语义。只有 sudo 从内核接收到 SIGHUP，并且不转发它，因为它期望只有当它的 child 进程也有它自己的时候它才会从内核接收到 SIGHUP（因为 sudo 的 parent （例如 bash) 会）。

我 reported the issue upstream，并且 它现在在 sudo 1.8.15 和以后的版本中被标记为已修复。

解决方法：

xterm -e 'sudo ./sig-counter; true'

# or for uses that don't implicitly use a shell:
xterm -e sh -c 'sudo some-cmd; true'

如果您的 -c 参数是单个命令，bash 通过执行它进行优化。处理另一个命令（在这种情况下是微不足道的 true），让 bash 坚持下去，运行 sudo 作为 child。我测试过，使用这种方法，当您关闭 xterm 时，sig-counter 从内核获得一个 SIGHUP。 （对于任何其他终端仿真器应该是相同的。）

我已经测试过了，它适用于 bash 和破折号。包含 handy-dandy signal-receiving-without-exiting 程序的源代码，您可以跟踪它以查看它接收到的所有信号。

---

此答案的其余部分可能略有不同步。在弄清楚 sudo 作为控制过程与 sudo 作为 child 的 shell 差异之前，我研究了一些理论和测试方法。

---

POSIX says pseudo-terminal 主端的 close() 导致："a SIGHUP signal shall be sent to the controlling process, if any, for which the slave side of the pseudo-terminal is the controlling terminal."

close() 的 POSIX 措辞意味着只能有一个处理进程将 pty 作为其控制终端。

当 bash 是 pty 从属端的控制进程时，它会做一些导致所有其他进程接收 SIGHUP 的事情。这是 sudo 所期望的语义。

ssh localhost，然后中止与 ~. 的连接或终止您的 ssh 客户端。

$ ssh localhost
ssh$ sudo ~/.../sig-counter  # without exec
   # on session close: gets a SIGHUP and a SIGCONT from the kernel

$ ssh localhost
ssh$ exec sudo ~/src/experiments-sys/sig-counter
   # on session close: gets only a SIGCONT SI_USER relayed from sudo

$ ssh -t localhost sudo ~/src/experiments-sys/sig-counter
   # on session close: gets only a SIGCONT SI_USER relayed from sudo

$ xterm -e sudo ./sig-counter
           # on close: gets only a SIGCONT SI_USER relayed from sudo

---

测试这个很棘手，因为 xterm 也会在退出和关闭 pty 之前自行发送 SIGHUP。其他终端仿真器（gnome-terminal、konsole）可能会也可能不会这样做。我必须自己编写一个 signal-testing 程序，才不会在第一次 SIGHUP 后死掉。

除非 xterm 运行 以 root 身份运行，否则它无法向 sudo 发送信号，因此 sudo 只能从内核获取信号。 （因为它是 tty 的控制进程，而 sudo 下的进程 运行ning 不是。）

sudo 手册页说：

Unless the command is being run in a new pty, the SIGHUP, SIGINT and SIGQUIT signals are not relayed unless they are sent by a user process, not the kernel. Otherwise, the command would receive SIGINT twice every time the user entered control-C.

在我看来，sudo 的 double-signal SIGHUP 回避逻辑是为 运行ning 设计的，作为交互式 shell 的 child。当不涉及交互式 shell 时（在交互式 shell 的 exec sudo 之后，或者当首先没有涉及 shell 时），只有 parent进程 (sudo) 收到 SIGHUP。

sudo 的行为对 SIGINT 和 SIGQUIT 有好处，即使在没有涉及 shell 的 xterm 中也是如此：在 xterm 中按 ^C 或 ^\ 后，sig-counter 接收到一个 SIGINT 或 SIGQUIT。 sudo 收到一个但没有转发。 si_code=SI_KERNEL 在两个进程中。

---

测试于 Ubuntu 15.04，sudo --version：1.8.9p5。 xterm -v: XTerm(312).

###### No sudo
$ pkill sig-counter; xterm -e ./sig-counter &

$ strace -p $(pidof sig-counter)
Process 19446 attached
   quit xterm (ctrl-left click -> quit)
rt_sigtimedwait(~[TERM RTMIN RT_1], {si_signo=SIGHUP, si_code=SI_USER, si_pid=19444, si_uid=1000}, NULL, 8) = 1  # from xterm
rt_sigtimedwait(~[TERM RTMIN RT_1], {si_signo=SIGHUP, si_code=SI_KERNEL}, NULL, 8) = 1    # from the kernel
rt_sigtimedwait(~[TERM RTMIN RT_1], {si_signo=SIGCONT, si_code=SI_KERNEL}, NULL, 8) = 18   # from the kernel
   sig-counter is still running, because it only exits on SIGTERM

 #### with sudo, attaching to sudo and sig-counter after the fact
 # Then send SIGUSR1 to sudo
 # Then quit xterm

 $ sudo pkill sig-counter; xterm -e sudo ./sig-counter &
 $ sudo strace -p 20398  # sudo's pid
restart_syscall(<... resuming interrupted call ...>) = ? 
ERESTART_RESTARTBLOCK (Interrupted by signal)
--- SIGUSR1 {si_signo=SIGUSR1, si_code=SI_USER, si_pid=20540, si_uid=0} ---
write(7, "\n", 1)                       = 1   # FD 7 is the write end of a pipe. sudo's FD 6 is the other end.  Some kind of deadlock-avoidance?
rt_sigreturn()                          = -1 EINTR (Interrupted system call)
poll([{fd=6, events=POLLIN}], 1, 4294967295) = 1 ([{fd=6, revents=POLLIN}])
read(6, "\n", 1)                        = 1
kill(20399, SIGUSR1)                    = 0   ##### Passes it on to child
read(6, 0x7fff67d916ab, 1)              = -1 EAGAIN (Resource temporarily unavailable)
poll([{fd=6, events=POLLIN}], 1, 4294967295

     ####### close xterm
--- SIGHUP {si_signo=SIGHUP, si_code=SI_KERNEL} ---
rt_sigreturn()                          = -1 EINTR (Interrupted system call)
--- SIGCONT {si_signo=SIGCONT, si_code=SI_KERNEL} ---   ### sudo gets both SIGHUP and SIGCONT
write(7, "", 1)                      = 1
rt_sigreturn()                          = -1 EINTR (Interrupted system call)
poll([{fd=6, events=POLLIN}], 1, 4294967295) = 1 ([{fd=6, revents=POLLIN}])
read(6, "", 1)                       = 1
kill(20399, SIGCONT)                    = 0   ## but only passes on SIGCONT
read(6, 0x7fff67d916ab, 1)              = -1 EAGAIN (Resource temporarily unavailable)
poll([{fd=6, events=POLLIN}], 1, 4294967295
## keeps running after xterm closes

 $ sudo strace -p $(pidof sig-counter)  # in another window
rt_sigtimedwait(~[RTMIN RT_1], {si_signo=SIGUSR1, si_code=SI_USER, si_pid=20398, si_uid=0}, NULL, 8) = 10
rt_sigtimedwait(~[RTMIN RT_1], {si_signo=SIGCONT, si_code=SI_USER, si_pid=20398, si_uid=0}, NULL, 8) = 18
## keeps running after xterm closes

sudo 下的命令 运行ning 仅在 xterm 关闭时看到 SIGCONT。

请注意，单击 xterm 标题栏上 window-manager 的关闭按钮只会使 xterm 手动发送 SIGHUP。通常这会导致 xterm 中的进程关闭，在这种情况下 xterm 之后退出。同样，这只是 xterm 的行为。

---

这就是 bash 在收到 SIGHUP 时所做的，产生 sudo 期望的行为：

Process 26121 attached
wait4(-1, 0x7ffc9b8c78c0, WSTOPPED|WCONTINUED, NULL) = ? ERESTARTSYS (To be restarted if SA_RESTART is set)
--- SIGHUP {si_signo=SIGHUP, si_code=SI_KERNEL} ---
--- SIGCONT {si_signo=SIGCONT, si_code=SI_KERNEL} ---
   ... write .bash history ...
kill(4294941137, SIGHUP)                = -1 EPERM (Operation not permitted)  # This is kill(-26159), which signals all processes in that process group
rt_sigprocmask(SIG_BLOCK, [CHLD TSTP TTIN TTOU], [CHLD], 8) = 0
ioctl(255, SNDRV_TIMER_IOCTL_SELECT or TIOCSPGRP, [26121]) = -1 ENOTTY (Inappropriate ioctl for device) # tcsetpgrp()
rt_sigprocmask(SIG_SETMASK, [CHLD], NULL, 8) = 0
setpgid(0, 26121)                       = -1 EPERM (Operation not permitted)
rt_sigaction(SIGHUP, {SIG_DFL, [], SA_RESTORER, 0x7f3b25ebf2f0}, {0x45dec0, [HUP INT ILL TRAP ABRT BUS FPE USR1 SEGV USR2 PIPE ALRM TERM XCPU XFSZ VTALRM SYS], SA_RESTORER, 0x7f3b25ebf2f0}, 8) = 0
kill(26121, SIGHUP)                     = 0 ## exit in a way that lets bash's parent see that SIGHUP killed it.
--- SIGHUP {si_signo=SIGHUP, si_code=SI_USER, si_pid=26121, si_uid=1000} ---
+++ killed by SIGHUP +++

我不确定其中的哪一部分可以完成工作。可能实际退出是技巧，或者它在启动命令之前所做的事情，因为 kill 和 tcsetpgrp() 都失败了。

---

我自己第一次尝试是：

xterm -e sudo strace -o /dev/pts/11 sleep 60

（其中 pts/11 是另一个终端。）sleep 在第一个 SIGHUP 后退出，因此没有 sudo 的测试只显示 xterm 手动发送的 SIGHUP。

sig-counter.c:

// sig-counter.c.
// http://whosebug.com/questions/32511170/terminate-sudo-python-script-when-the-terminal-closes
// gcc -Wall -Os -std=gnu11 sig-counter.c -o sig-counter
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>

#define min(x, y) ({                \
    typeof(x) _min1 = (x);          \
    typeof(y) _min2 = (y);          \
    (void) (&_min1 == &_min2);      \
    _min1 < _min2 ? _min1 : _min2; })

int sigcounts[64];
static const int sigcount_size = sizeof(sigcounts)/sizeof(sigcounts[0]);

void handler(int sig_num)
{
    sig_num = min(sig_num, sigcount_size);
    sigcounts[sig_num]++;
}

int main(void)
{
    sigset_t sigset;
    sigfillset(&sigset);
    // sigdelset(&sigset, SIGTERM);

    if (sigprocmask(SIG_BLOCK, &sigset, NULL))
        perror("sigprocmask: ");

    const struct timespec timeout = { .tv_sec = 60 };
    int sig;
    do {
        // synchronously receive signals, instead of installing a handler
        siginfo_t siginfo;
        int ret = sigtimedwait(&sigset, &siginfo, &timeout);
        if (-1 == ret) {
            if (errno == EAGAIN) break; // exit after 60 secs with no signals
            else continue;
        }
        sig = siginfo.si_signo;
//      switch(siginfo.si_code) {
//      case SI_USER:  // printf some stuff about the signal... just use strace

        handler(sig);
    } while (sig != SIGTERM );

    //sigaction(handler, ...);
    //sleep(60);
    for (int i=0; i<sigcount_size ; i++) {
        if (sigcounts[i]) {
            printf("counts[%d] = %d\n", i, sigcounts[i]);
        }
    }
}

我的第一次尝试是使用 perl，但安装信号处理程序并不能阻止 perl 在信号处理程序返回后退出 SIGHUP。我看到消息出现在 xterm 关闭之前。

cmd=perl\ -e\ \''use strict; use warnings; use sigtrap qw/handler signal_handler normal-signals/; sleep(60); sub signal_handler { print "Caught a signal $!"; }'\';
xterm -e "$cmd" &

Apparently perl 信号处理相当复杂，因为 perl 必须 defer them until it's not in the middle of something that doesn't do proper locking.

C 中的 Unix 系统调用是进行系统编程的 "default" 方式，因此消除了任何可能的混淆。 strace 通常是一种避免实际编写日志记录/打印代码来玩弄东西的廉价方法。 :P