主页 / user-696568

Yakog's questions

Martin Hope
Yakog
Asked: 2025-03-01 09:23:20 +0800 CST
  • 6

我正在使用Ubuntu 22.04.5 LTS以下操作系统和 bash 版本：

GNU bash, version 5.1.16(1)-release (x86_64-pc-linux-gnu)

我在“man bash”的 INVOCATION 部分下发现以下内容：

当 bash 作为交互式登录 shell 或使用 --login 选项作为非交互式 shell调用时 ，它首先从文件 /etc/profile 中读取并执行命令（如果该文件存在）。读取该文件后，它会按顺序查找 ~/.bash_profile、~/.bash_login 和 ~/.profile，然后从第一个存在且可读的文件中读取并执行命令。

我知道bash可以通过两种方式“登录”：

  1. 零参数在名称前有一个破折号 ( -bash)
  2. --loginbash 使用标志/选项启动。

在“man bash”中，他们明确标记了第二种情况（如果他们想标记两种情况，他们会写上“非交互式登录 shell”；Stephen Kitt在他的回答中也说这只适用于第二种情况）。这意味着如果我以第一种方式启动非交互式登录 bash，则~/.profile不应执行文件中的命令。然而，事实并非如此。我添加echo HI到给定文件中并在 GNOME 终端仿真器 () 中运行以下命令/dev/pts/0以启动非交互式登录 bash：

exec -l bash -c 'echo $-;echo $0;shopt;sleep 10s'

尽管根据手册不应该显示文本（“HI”），但它还是显示在终端上。

为什么会发生这种情况？

我在这里找到了我的问题的一个潜在答案。在我看来，这个编译时选项似乎被取消注释，所以 bash 读取了“~/.profile”文件。有人知道如何检查该选项是否真的被取消注释吗？

bash
Martin Hope
Yakog
Asked: 2025-02-26 05:12:06 +0800 CST
  • 9

man bash我发现交互式 shell 的定义如下：

交互式 shell 是指不使用非选项参数（除非指定了 -s）和 -c 选项启动的 shell，其标准输入和错误均连接到终端（由 isatty(3) 确定），或使用 -i 选项启动的 shell。如果 bash 是交互式的，则设置 PS1 并且 $- 包含 i，从而允许 shell 脚本或启动文件测试此状态。

因此，交互式 shell 是这样的：

  1. 没有非选项参数（除非-s指定），没有-c选项并且其标准输入和错误都连接到终端；或者
  2. 有-i选择

我写了下面的例子：

bash << EOF
echo '$-'
EOF

输出结果如下：

himBHs

因此，它看起来像是一个交互式 shell（它有i）。但是，我不清楚当标准输入不是终端时它如何能够交互... 此类重定向的文档中写了以下内容（here documents）：

这种类型的重定向指示 shell 从当前源读取输入，直到看到仅包含分隔符（没有尾随空格）的行。 然后将读取到该点的所有行用作命令的标准输入（或文件描述符 n，如果指定了 n）。

它表示标准输入是读取到分隔符的所有行（我假设它们随后通过将命令的标准输入重定向到管道或类似的东西传递给命令）。因此，标准输入不是（连接到）终端。

为什么会发生这种情况？为什么在这种情况下 bash 是交互式的？

bash
Martin Hope
Yakog
Asked: 2025-02-22 21:46:15 +0800 CST
  • 14

我正在使用 Linux 和以下版本的 bash：

GNU bash, version 5.1.16(1)-release (x86_64-pc-linux-gnu)

当我输入：

echo file{[1,2],3}.txt

我希望首先完成括号扩展，因此：

echo file[1,2].txt file3.txt

之后，我预计它会停在那里，因为 [1,2] 不是有效的通配符。但是，它给出了以下输出：

file[1.txt file2].txt file3.txt

为什么？

当前目录中的文件列表（命令结果ls）：

go.mod  hello.sh  hi  main.go
bash
Martin Hope
Yakog
Asked: 2025-02-17 19:40:33 +0800 CST
  • 7

我正在使用 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因此取该值）...提前致谢

bash
Martin Hope
Yakog
Asked: 2025-01-25 22:39:33 +0800 CST
  • 8

我正在使用 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)
    }
}
signals
Martin Hope
Yakog
Asked: 2025-01-25 16:44:14 +0800 CST
  • 7

我正在使用 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，那么为什么在这种情况下陷阱不会触发？

相关问题。

bash
Martin Hope
Yakog
Asked: 2025-01-22 19:03:52 +0800 CST
  • 7

我正在使用 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

怎么办？为什么？

linux
Martin Hope
Yakog
Asked: 2025-01-17 08:01:24 +0800 CST
  • 5

从我启动伪终端（CTRL+ALT+T）到 shell 开始监听键盘输入的过程中，具体有哪些步骤？

我知道它大致是按照终端进程调用的方式进行的dev/pts/ptmx，然后创建从属端（例如/dev/pts/0），然后终端进程自行分叉（我猜？），设置会话并执行shell。

然而，我很好奇它究竟是如何工作的。

在此过程中特别令我困惑的是以下内容：

  1. 我以为我的终端仿真器（伪终端）是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，还是怎样？
  2. 我以为会话是专门与终端绑定的东西。也就是说，每个终端只有一个会话，仅此而已。然而，当我深入研究时，我发现这是“内核的事情”，每个进程都有一个会话，包括/usr/libexec/gnome-terminal-server。那么为什么它会为 bash 创建一个新会话，而不是直接使用来自 的会话，/usr/libexec/gnome-terminal-server因为那实际上是一个终端？
  3. 如何/usr/libexec/gnome-terminal-server知道要启动/执行哪个 shell（在我的情况下是 bash）？它是从某处读取的吗？我可以更改它吗？

我很好奇这些步骤究竟是如何进行的。

谢谢

bash
Martin Hope
Yakog
Asked: 2025-01-14 05:48:18 +0800 CST
  • 5

我有以下两个简单的程序。

家长：

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它时，它不会终止进程......为什么？

bash
Martin Hope
Yakog
Asked: 2025-01-12 09:36:22 +0800 CST
  • 5

我开始学习 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

为什么会发生这种情况，我忽略了什么？

bash
Martin Hope
Yakog
Asked: 2025-01-07 07:28:47 +0800 CST
  • 5

我最近开始学习操作系统和 Linux 内核。我对终端很感兴趣，所以我从那里开始，但是，我很快就遇到了一个问题。我写了一个稍长的问题，因为我想让你确切地看到问题可能出现在我的理解中的位置，并确切地知道我不清楚的地方。提前谢谢 :)

我已阅读以下文章和问答：

  1. 揭秘 TTY
  2. 终端、控制台和 Shell 指南
  3. Stéphane Chazelas的回答

然而，我无法理解终端（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 线路规则“逻辑上”到底位于哪里？

bash