我正在使用 bash，版本：
GNU bash, version 5.1.16(1)-release (x86_64-pc-linux-gnu)
我编写了以下脚本：
#!/usr/bin/bash
a=11
b=4
c=7+b
if [[ a -eq c ]]
then
echo "ok"
else
echo "not ok"
fi
它打印“ok”。当我将其更改a为 10 时，它打印“not ok”。所以我有一个简单的问题，do[[ ]]和(( ))makes 是否“传递求值”（在我的示例中，这意味着c首先求值为7+b然后b求值为4最后它总体变为11）？
我之所以问这个问题，是因为我与人工智能（chatGPT、gemini、claude）发生了严重的“争斗”，他们说这种评估不会发生，但我的例子却表明并非如此（他们说c被评估为7+b，并且由于它不是一个数字，0因此取该值）...提前致谢
我正在使用 Linux（ubuntu）。
当我man 7 signal在终端中输入 (manual 2020-12-21) 时，我发现 SIGCHLD 出现以下情况：
SIGCHLD P1990 Ign Child stopped or terminated
因此，它表明SIGCHLD仅在这两种情况下才会生成信号。它并未说明子进程何时继续运行。
然而，在 POSIX 中，它规定如下：
SIGCHLD Child process terminated, stopped,
[XSI] or continued.
因此，当 OS 支持 XSI 时，子进程继续时也会生成此信号。我还编写了一些简单的子进程/父进程程序，可以确认这一点。既然 Linux 支持 XSI，为什么手册中不包括 SIGCHLD 的“继续”场景？如果手册不完整（或者我不明白它的用途），那么手册的目的是什么？
此外，我发现以下有关SIGCHLD 的答案不完整。
下面是代码。这是一段简单的 golang 代码。父进程通过经典的 fork/exec 启动子进程。然后它为 SIGCHLD 信号注册一个处理程序，就这样。父进程和子进程每 10 秒打印一条消息。构建两个程序后，我通过命令运行它们。我通过和控制子进程的./parent行为（T<->状态） 。R/Skill -SISTOP child_process_idkill -SIGCONT child_process_id
家长：
package main
import (
"fmt"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
attr := &syscall.ProcAttr{
Files: []uintptr{0, 1, 2},
}
_, err := syscall.ForkExec("./child/child", []string{"child"}, attr)
if err != nil {
fmt.Println("Error:", err)
return
}
ch := make(chan os.Signal, 1)
signal.Notify(ch, syscall.SIGCHLD)
go func() {
for {
select {
case <-ch:
fmt.Println("SIGNAL")
}
}
}()
for {
fmt.Println("Parent is live")
time.Sleep(10 * time.Second)
}
}
孩子：
package main
import (
"fmt"
"time"
)
func main() {
for {
fmt.Println("hi from child")
time.Sleep(time.Second * 10)
}
}
我正在使用 linux（Ubuntu）和 bash。
我写了一个简单的 Go 程序。实际上是无限循环，每 20 秒打印一次文本。
package main
import (
"fmt"
"time"
)
func main() {
for {
fmt.Println("Hi from program 1")
time.Sleep(time.Second * 20)
}
}
SIGCHLD首先，我使用以下命令为信号注册一个陷阱：
trap 'echo "hi you"' SIGCHLD
接下来，我使用以下命令异步启动一个程序（在后台）：
./program &
我将其作为后台作业启动，以便 bash 可以使用终端。当我执行命令时：
kill -SIGSTOP process_id
陷阱被触发，并且消息“hi you”按预期显示。但是，当我运行：
kill -SIGCONT process_id
恢复该进程，进程继续运行（打印“Hi from program 1”），但不显示陷阱消息（“hi you”）。我kill从另一个终端调用这些命令。
我在bash 文档中发现以下内容：
对于每个退出的子进程，都会执行 SIGCHLD 上的任何陷阱。
我可以将其理解为排他性的。换句话说，SIGCHLD只有当子进程退出时，陷阱才会激活。如果是这样，我就会明白为什么我的例子不起作用。然而，SIGCHLD当子进程被挂起时，陷阱也会被激活。
为什么会发生这种情况？恢复该过程也会产生信号SIGCHLD，那么为什么在这种情况下陷阱不会触发？
相关问题。
我正在使用 Ubuntu（Linux）。
我有以下两个简单的程序。
家长：
package main
import (
"fmt"
"syscall"
"time"
)
func main() {
attr := &syscall.ProcAttr{
Files: []uintptr{0, 1, 2},
Sys: &syscall.SysProcAttr{ // child in its own group
Setpgid: true,
Pgid: 0,
},
}
_, err := syscall.ForkExec("./child/child", []string{"child"}, attr)
if err != nil {
fmt.Println("Error:", err)
return
}
for {
fmt.Println("Parent is live")
time.Sleep(10 * time.Second)
}
}
儿童（同组儿童）：
package main
import (
"fmt"
"time"
)
func main() {
for {
fmt.Println("hi from child")
time.Sleep(time.Second * 20)
}
}
启动父程序（）后，调用（具体来说）命令./parent的结果如下：psps -t /dev/pts/0 -o pid,ppid,pgid,stat,comm
PID PPID PGID STAT COMMAND
466922 466896 466922 Ss bash
467049 466922 467049 Sl+ parent
467054 467049 467054 Sl child
终止父进程（使用或kill -SIGKILL 467049）后，子进程继续工作（S/R 状态）。这正是我所期望的。kill -SIGINT 467049CTRL-C
PID PPID PGID STAT COMMAND
466922 466896 466922 Ss+ bash
467054 467049 467054 Sl child
让我感到困惑的是以下场景。首先，我启动父进程（./parent）。ps命令的结果与前一种情况相同。然后我使用kill -SIGTSTP 467054或暂停子进程kill -SIGSTOP 467054。命令的结果ps如下：
PID PPID PGID STAT COMMAND
466922 466896 466922 Ss bash
467049 466922 467049 Sl+ parent
467054 467049 467054 Tl child
然后，我终止父进程（使用或kill -SIGKILL 467049）。出于某种原因，在这种情况下子进程也会被终止！命令结果：kill -SIGINT 467049CTRL-Cps
PID PPID PGID STAT COMMAND
466922 466896 466922 Ss+ bash
怎么办？为什么？
从我启动伪终端（CTRL+ALT+T）到 shell 开始监听键盘输入的过程中，具体有哪些步骤？
我知道它大致是按照终端进程调用的方式进行的dev/pts/ptmx，然后创建从属端（例如/dev/pts/0），然后终端进程自行分叉（我猜？），设置会话并执行shell。
然而，我很好奇它究竟是如何工作的。
在此过程中特别令我困惑的是以下内容：
xterm-256color因为输入 时得到的就是这个echo $TERM。所以xterm会进一步调用ptmx。但是，当我检查 shell（bash）的 PPID 时，它实际上是/usr/libexec/gnome-terminal-server。所以我很困惑，这两者有什么区别？是xterm先 fork/exec/usr/libexec/gnome-terminal-server然后调用ptmx并进一步 fork/exec shell，还是怎样？/usr/libexec/gnome-terminal-server。那么为什么它会为 bash 创建一个新会话，而不是直接使用来自 的会话，/usr/libexec/gnome-terminal-server因为那实际上是一个终端？/usr/libexec/gnome-terminal-server知道要启动/执行哪个 shell（在我的情况下是 bash）？它是从某处读取的吗？我可以更改它吗？我很好奇这些步骤究竟是如何进行的。
谢谢
我有以下两个简单的程序。
家长：
package main
import (
"fmt"
"syscall"
)
func main() {
attr := &syscall.ProcAttr{
Files: []uintptr{0, 1, 2},
Sys: &syscall.SysProcAttr{ // child in its own group
Setpgid: true,
Pgid: 0,
},
}
_, err := syscall.ForkExec("./child/child", []string{"child"}, attr)
if err != nil {
fmt.Println("Error:", err)
return
}
}
孩子：
package main
import (
"fmt"
"time"
)
func main() {
for {
fmt.Println("hi from child")
time.Sleep(time.Second * 5)
}
}
输出ps：
yakog@yakog-computer:~/goprojects/parent$ ps -o pid,ppid,pgid,uid,wchan,stat,tt,command -t /dev/pts/19
PID PPID PGID UID WCHAN STAT TT COMMAND
1867701 1867320 1867701 1000 do_sel Ss+ pts/19 bash
1870508 2118 1870508 1000 ep_pol Sl pts/19 child
当我按下CTRL-Z或 时CTRL-C，它没有任何效果。这正是我所期望的，因为进程 1870508 不是前台作业的一部分，并且CTRL-Z/CTRL-C调用kill -SIGTSTP -1867701/ kill -SIGINT -1867701。因此，1870508 不会收到这些信号。
另外，当我调用kill -SIGINT 1870508或 时kill -SIGSTOP 1870508，进程被终止/暂停。我仍然可以理解。虽然 1870508 不是前台作业的一部分，但使用kill命令我们“直接”将信号发送给进程。
但是，为什么不起作用kill -SIGTSTP 1870508？启动./parent进程并调用kill -SIGTSTP 1870508命令后，实际上什么都没有发生（1870508 仍然具有状态R/S并继续打印到终端）。我不明白为什么它没有暂停进程（将其移动到）。它应该与和T相同（我们“直接”向进程发送 -SIGTSTP），但是，在这种情况下它没有效果。-SIGINT-SIGSTOP
奇怪的是，如果我们改变父代码（下面的代码）并使其在子进程创建后继续执行，那么它就kill -SIGTSTP 1870508可以正常工作（子进程被暂停）。
package main
import (
"fmt"
"os/signal"
"syscall"
"time"
)
func main() {
attr := &syscall.ProcAttr{
Files: []uintptr{0, 1, 2},
Sys: &syscall.SysProcAttr{ // child in its own group
Setpgid: true,
Pgid: 0,
},
}
_, err := syscall.ForkExec("./child/child", []string{"child"}, attr)
signal.Ignore(syscall.SIGTSTP)
if err != nil {
fmt.Println("Error:", err)
return
}
for {
fmt.Println("hi from parent")
time.Sleep(time.Second * 7)
}
}
此外，当我调用kill -SIGSTOP 1870508（将进程移动到T状态）然后调用kill -SIGINT 1870508它时，它不会终止进程......为什么？
我开始学习 Linux tty 和信号并遇到了一些麻烦。
我正在阅读并使用《TTY 揭秘》作为参考。
我做了两个简单的golang程序。
家长：
package main
import (
"fmt"
"syscall"
"time"
)
func main() {
attr := &syscall.ProcAttr{
Files: []uintptr{0, 1, 2},
}
_, err := syscall.ForkExec("./child/child", []string{"child"}, attr)
if err != nil {
fmt.Println("Error:", err)
return
}
for {
fmt.Println("hi from parent")
time.Sleep(time.Second * 10)
}
}
孩子：
package main
import (
"fmt"
"os/signal"
"syscall"
"time"
)
func main() {
signal.Ignore(syscall.SIGTSTP) // golang's way to handle (ignore) signal
for {
fmt.Println("hi from child")
time.Sleep(time.Second * 5)
}
}
它们非常简单。两者都只是每 5/10 秒向 tty 打印一条消息。唯一的区别是子进程忽略了 SIGTSTP（ctrl-z）信号。因此，当我按下 ctrl-z 时，它会暂停父进程，而不会暂停子进程。这正是我所期望的。然而，我没有想到的是，整个组从前台移到了后台组。它与TTY 揭秘形成对比。具体来说：
当前台作业中的所有进程都已暂停时，会话领导者将从 TTY 设备读取当前配置，并将其存储起来以供以后检索。会话领导者继续使用 ioctl 调用将自己安装为 TTY 的当前前台进程组。然后，它会打印类似“[1]+ Stopped”的内容来通知用户作业刚刚被暂停。
它表示仅当前台作业中的所有进程都已暂停时，会话领导者（shell / bash）才会将该组移至后台作业......
ps l -t /dev/pts/0ctrl-z 前后的结果：
yakog@yakog-computer:~/goprojects/parent$ ps l -t /dev/pts/0
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
0 1000 1747467 1747441 20 0 14288 5632 do_wai Ss pts/0 0:00 bash
0 1000 1747496 1747467 20 0 1225432 1792 ep_pol Sl+ pts/0 0:00 ./parent
0 1000 1747501 1747496 20 0 1225424 1664 ep_pol Sl+ pts/0 0:00 child
yakog@yakog-computer:~/goprojects/parent$ ps l -t /dev/pts/0
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
0 1000 1747467 1747441 20 0 14288 5632 do_sel Ss+ pts/0 0:00 bash
0 1000 1747496 1747467 20 0 1225432 1792 do_sig Tl pts/0 0:00 ./parent
0 1000 1747501 1747496 20 0 1225680 1792 ep_pol Sl pts/0 0:00 child
如果我将忽略 ( signal.Ignore(syscall.SIGTSTP)) 从子进程移至父进程，则一切正常（从我的角度来看）。子进程暂停 (T)，父进程正常恢复 (R/S)，但该组仍是前台作业。
yakog@yakog-computer:~/goprojects/parent$ ps l -t /dev/pts/0
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
0 1000 1749437 1749410 20 0 14420 5632 do_wai Ss pts/0 0:00 bash
0 1000 1749957 1749437 20 0 1225448 1920 ep_pol Sl+ pts/0 0:00 ./parent
0 1000 1749962 1749957 20 0 1225412 1664 ep_pol Sl+ pts/0 0:00 child
yakog@yakog-computer:~/goprojects/parent$ ps l -t /dev/pts/0
F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND
0 1000 1749437 1749410 20 0 14420 5632 do_wai Ss pts/0 0:00 bash
0 1000 1749957 1749437 20 0 1225448 1920 ep_pol Sl+ pts/0 0:00 ./parent
0 1000 1749962 1749957 20 0 1225668 1792 do_sig Tl+ pts/0 0:00 child
为什么会发生这种情况，我忽略了什么？
我最近开始学习操作系统和 Linux 内核。我对终端很感兴趣，所以我从那里开始，但是，我很快就遇到了一个问题。我写了一个稍长的问题，因为我想让你确切地看到问题可能出现在我的理解中的位置，并确切地知道我不清楚的地方。提前谢谢 :)
我已阅读以下文章和问答：
然而，我无法理解终端（tty）线路规则的确切逻辑位置，因为我发现第一篇文章和Stéphane Chazelas的回答之间存在不一致（正如我天真的理解的那样）。
TTY 揭秘首先使用下面的图片：
它表示 TTY 驱动程序通过 表示tty_io.c，而默认线路规程通过 表示n_tty.c。进程（如 bash）与 TTY 驱动程序（tty_io.c）通信。实际上，在实践中，使用代表整个设备（UART 驱动程序 + 线路规程 + TTY 驱动程序）的文件。UART 驱动程序是某种“串行”类驱动程序，它一方面与物理线路（和进一步的终端）通信，另一方面与线路规程通信。
下一张来自《TTY 揭秘》的图片是：
一切都一样，只是现在我们有了模拟器和虚拟终端。唯一的区别是不再使用 UART 驱动程序，而是使用“控制台”驱动程序。
最后一张图显示了伪终端的情况。在这种情况下，我们有一个主端和一个从端。终端仿真器被“推入”用户空间。此外，我们有两个文件，其中仿真器与主文件交互（/dev/ptmx），而进程（shell）与从文件交互（/dev/pts/..）。在这种情况下，使用 pty 驱动程序，我想说，从逻辑上讲，与前面的情况一样，它位于图中写有“PTY 主端”的位置。
一切都对我有用 (或者至少我认为是这样)，然后我偶然看到了Stéphane Chazelas的回答：
很多智能都存在于 tty 线路规则中。线路规则是一个软件模块（驻留在驱动程序中，在内核中），它被推到串行/pty 设备之上，位于该设备和线路/电线之间（pty 的主端）。
根据图片，我们有一个通过内核中的驱动程序表示的串行/控制台/pty“设备”（第一张是 UART 驱动程序，第二张是模拟器，第三张是“主端”），然后是线路规程（作为驱动程序的一部分，位于其上方）。但是，图片上的下一个组件是 TTY 驱动程序（tty_io.c），而不是 Stéphane Chazelas 所写的线路/电线……也许 Stéphane 说“串行/pty 设备”时想到的是 TTY 驱动程序，但这对我来说没有意义，因为那样的话我们就会得到，例如。UART (serial) driver <-> line discipline <-> TTY driver/UART (serial) driver此外，在图片上，TTY 驱动程序不会对它们进行区分，它只是tty_io.c
我很困惑。我遗漏了什么？tty 线路规则“逻辑上”到底位于哪里？