今天是 Rust 系统编程的第二部分。具体包含如下内容：

• 什么是系统信号及如何处理
• 什么是 stdout、 stdin 和 stderr，以及如何有效地使用它们
• 据写入标准输出（stdout）并从标准输入（stdin）读取数据，而不是打印，这样做的好处是什么
• 管理父进程和子进程及其执行顺序

为了在实践中演示上面列出的主题，我们将构建一个 UNIX mini-shell，它将能够从终端中的用户获取命令并执行它们。该程序还将处理一些无效的命令，并优雅地处理被卡住的程序。

stdin, stdout 和 stderr

你可能熟悉计算机中的数据流，但不仅仅是像水流，它指的是从源到端点的数据流。流允许连接命令、进程、文件等。有三个特殊的流：

• stdin (标准输入) ：接受文本作为输入
• stdout (标准输出) ：在 stdout 流中存储文本输出
• stderr (标准错误) ：当流中发生错误时，错误消息将存储在此流中

Linux 系统是面向文件的。这意味着几乎所有的流都被视为文件，并且这些流都是基于每个文件类型所具有的唯一标识符代码来处理的。对于 stdio (标准输出、输入和错误的集合) ，分配的值为：stdin 为 0，stdout 为 1，stderr 为 2。如果我们想从命令行读取文本流，在 C 语言中，我们使用 read() 函数，并提供代码 0 作为 stdin 的参数之一(图1-a)。

在 Rust 中，从 stdio 读取和写入有点不同，但是基本原理是一样的。为了更好地演示它们的用途，我们将开始为迷你 Shell 程序编写代码。开始我们将创建一个循环，要求用户输入系统将执行的命令。我们需要创建的前两个功能是写入到标准输出和从标准输入读取。

use std::io::{self, Write};
/// flushes text buffer to the stdout
fn write_to_stdout(text: &str) -> io::Result<()> {
    io::stdout().write(text.as_ref())?;
    io::stdout().flush()?; // flush to the terminal
    Ok(())
}

我们将使用一个标准的 io > 模块写入终端。函数 write_to_stdout() 不是通过复制传递 String，而是将对字符串片段的引用作为参数。str 不同于 String。它是 Rust 所指的一个切片，是对一个字符串的一部分的引用。如果你想更好地理解这两者之间的区别，我建议你阅读 Rust 的官方书籍的第四章^[1]。

函数 write_to_stdout() 的作用是返回 Result 对象，它可以是 Ok，也可以是 Err。正如这些名字所暗示的，如果一切按计划进行，将返回 Ok 否则 Err 将返回。这种过程在 Rust 中普遍如此，所以，针对要返回 Err，在函数调用结束时可以写一个特殊的符号 ？ 表示可能会出错。

在函数内部，我们调用一个 write() 函数来填充 stdout 的文本缓冲区，然后在屏幕上刷新文本。在 write() 中，我们使用了 as_ref() 方法，该方法将字符串切片转换为 ASCII 字节文本，因为这是上面提到的函数作为参数所期望的。

接下来，我们需要构建一个函数来读取用户输入的命令并处理它。为此，我们将编写一个自定义函数 get_user_command()，它返回 String。

/// fetch the user inputted command from terminal
fn get_user_command() -> String {
    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap(); // not receommended
    
    if input.ends_with('\n') {
        input.pop(); // remove last char
    }
    input
}

该函数从终端读取一个完整的行并将值复制到输入变量中。read_line() 接受输入 String 变量的可变引用，在函数调用中取消引用，写入用户提供的命令，并返回 Result。当我们从 stdin 读取一行时，它的 EOL (行尾)被终止，其中包括末尾的 \n 控制字符，我们需要在返回输入之前删除它。

最后，我们将输入和输出函数与迷你 shell 程序粘合在一起。

use std::io::{self, Write};
fn main() {
    loop { run_shell(); }
}
fn run_shell() {
    let shellname = "ghost# ";
    match = write_to_stdout(&shellname) {
        Ok(v) => v,
        Err(e) => {
            eprintln!("Unable to write to stdout : {}", e);
            process::exit(1);
        },
    }
    let cmnd = get_user_command();
    if let Err(_) = process::Command::new(&cmnd).status() {
        eprintln!("{}: command not found!", &cmd);
    }
}

在 main() 函数中，我们运行一个循环，将 shell 名称打印到终端屏幕，并等待用户输入命令。run_shell() 使用我们以前定义的函数写入 stdout，并在打印过程中处理错误。如果出现错误，它会通知用户并退出程序，错误代码为1(编译失败)。

接下来，它读取用户提供的命令，并将该命令传递给新创建的进程。然后我们检查命令执行的状态，如果命令不成功，我们通知用户“命令没有找到”，并且我们不退出，而是返回提示用户输入的循环。

通过 cargo run 运行该程序，我们应该会看到类似下面的输出：

这里要问的一个很好的问题是，为什么我们使用读写函数，而不是简单地打印到屏幕上。这背后的原因是，像 read 和 write 这样的指令是所谓的 Async-Signal Safe 函数，而 C 的 printf 不是。可以在信号处理程序中安全地调用它们(我们将在下面讨论)。

保证异步信号安全的函数在发送信号时不会被中断或干扰。例如，如果我们在  println!() 调用和信号发生的中间，信号的处理程序本身调用  println!() 可能会导致未定义行为。因为在这种情况下，两个  println!() 的输出会交织在一起。

系统信号

为了改进我们的迷你 Shell，我们必须处理系统信号。UNIX 环境中的信号是一种通知，由操作系统发送给进程以通知某个事件，这通常会中断进程。每个信号都有一个唯一的名称和分配给它的整数值。你可以通过在终端中键入 kill -l 来查看系统信号的完整列表。

默认情况下，每个信号都有其定义的处理程序，该处理程序是在某个信号到达时调用的函数。我们可以修改对这些信号的处理(我们将为迷你 shell 项目这样做)。然而，一些信号处理程序不能被修改。

对于我们的项目来说，我们将看到以下四个信号:

• SIGINT：通过按 Ctrl+C 使系统向正在运行的进程发送 INT 信号。默认情况下，这会导致进程立即终止。SIGINT 的信号码是 2。
• SIGQUIT：通过按 Ctrl+\ 使系统将向正在运行的进程发送 QUIT 信号。这也会终止该进程，但更优雅。这将执行需要清理的绝对必要的资源。SIGQUIT 的信号代码是 3。
• SIGALRM 就像一个时钟，以秒为单位倒计时。如果秒计数为零，则取消任何挂起的报警，并向进程发送 SIGALRM 信号。SIGALRM 的信号代码是 14。
• SIGKILL 是系统发出的强制进程停止的最强信号。此信号不能由用户手动处理，但系统仍将在进程终止后执行清理。SIGKILL 的信号代码是 9。

现在，是时候确认在 Rust 中，我们将如何处理上面列出的信号了(除了 SIGKILL，因为我们不能更改它的默认行为)。例如，如果在 Linux 终端中运行 cat 命令时没有文件参数，那么它将陷入无限循环。当这种情况发生在我们的 mini-shell 中时，我们将发出 SIGINT 信号，以便它将中断信号转发给子进程。这将只会终止循环，但将保持我们的 shell 程序运行。

use signal_hook::{iterator, consts::{SIGINT};
use std::{process, thread, error::Error};
use nix::sys::signal::{self, Signal};
/// Registers UNIX system signals
fn register_signal_handlers() -> Result<(), Box<dyn Error>>  {
    let mut signals = iterator::Signals::new(&[SIGINT])?;
    // signal execution is forwarded to the child process
    thread::spawn(move || {
        for sig in signals.forever() {
            match sig {
                SIGINT => assert_ne!(0, sig), // assert that the signal is sent
                _ => continue,
            }
        }
    });
    Ok(())
}

首先，我们创建一个信号迭代器，它存储信号引用的向量。这里我们指出哪些信号需要被处理。接下来，我们需要将信号转发给正在运行的子进程，并在其上执行所需的行为。这是通过生成一个返回 JoinHandler 的新线程来实现的。

此处理程序将在删除后分离子进程。这意味着当 SIGINT 到达子进程时，该进程将与父进程分离，它只会中断子进程正在执行的任何操作，而父进程将继续运行。如果执行中没有子进程，那么它将什么也不做。

我们在信号迭代器上使用 forever() 函数，它对到达的信号进行无限循环。一旦信号到达，它将评估与匹配的情况，如果它匹配 SIGINT，将断言信号已成功发送。对于任何其他信号，迭代器将继续等待下一个信号。

既然我们重新接管了 SIGINT 信号，只处理子进程，那么如果我们想完全退出程序呢？我们将处理一个不同的信号，并让它向标准输出打印 “Goodbye”，然后优雅地退出。对于这种情况，我们将使用 SIGQUIT 信号，它可以通过按下 Ctrl + \ 键发送。

use signal_hook::consts::SIGQUIT;
// .. previous function introduction and matching ..
        SIGQUIT => {
            write_to_stdout("Goodbye!\n").unwrap();
            process::exit(0);
        },
// .. rest of the function ..

当调用 SIGQUIT 信号时，它在迭代器中进行匹配，这将调用 write_to_stdout() 函数。然后程序退出，代码 0，在 Linux 中代表成功。注意，我们正在从 signal_hook 库导入 SIGNAL 常量，该库是一个更容易处理 Unix 信号的库。

最后，我们将为我们的程序添加一个小特性。用户将在程序启动时提供一个整数。这个数字将用作程序执行时间的倒计时。例如，如果用户提供 5，那么在启动子进程时将调用 alarm(5)。如果一个函数在倒计时结束时没有完成，我们手动定义的 SIGALRM 信号将杀死它并将程序返回到初始状态。

use signal_hook::consts::SIGALRM;
use nix::sys::signal::{self, Signal};
use nix::unistd::{alarm, Pid};
/// alarm will be called from `execute_shell(timeout: u32)`
/// after function collects user input it calls `alarm::set(timeout)`
// .. beginning of the register_signal_handlers function ..
        SIGALRM => {
            write_to_stdout("This's taking too long...\n").unwrap();
            // when alarm goes off it kills child process
            signal::kill(Pid::from_raw(0), Signal::SIGINT).unwrap()
        },
// .. rest of the function ..

当 SIGALRM匹配时，首先，它将写入到标准输出，然后，它将执行一个非常有趣的操作。它将使用 signal::kill() 函数在它所操作的进程上发送 SIGINT 信号。但是，由于同一个函数通过将其转发给子进程来处理 SIGINT，它只会杀死子进程，并返回到运行 mini-shell 的主程序。代码如下：

use signal_hook::{iterator, consts::{SIGINT, SIGALRM, SIGQUIT}};
use std::{process, thread, error::Error};
use nix::sys::signal::{self, Signal};
use nix::unistd::{alarm, Pid};
/// Register UNIX system signals
fn register_signal_handlers() -> Result<(), Box<dyn Error>>  {
    let mut signals = iterator::Signals::new(&[SIGINT, SIGALRM, SIGQUIT])?;
    // signal execution is forwarded to the child process
    thread::spawn(move || {
        for sig in signals.forever() {
            match sig {
                SIGALRM => {
                    write_to_stdout("This's taking too long...\n").unwrap();
                    // when alarm goes off it kills child process
                    signal::kill(Pid::from_raw(0), Signal::SIGINT).unwrap()
                },
                SIGQUIT => {
                    write_to_stdout("Good bye!\n").unwrap(); // not safe
                    process::exit(0);
                },
                SIGINT => assert_ne!(0, sig), // assert that the signal is sent
                _ => continue,
            }
        }
    });
    Ok(())
}

如果你通过终端运行我们的 mini-shell，应该得到如下预期的结果：

你可以在这个 GitHub 存储库中找到这个 mini-shell 的完整代码^[2]，其中包括其他一些特性。

总结

今天我们学习了什么是 stdin、 stdout 和 stderr，以及如何正确使用它们。我们研究了常见的 UNIX 系统信号，并手动处理了其中的三个，以满足迷你 shell 程序的需要。第 1 部分的知识使我们能够构建一个程序来安全快速地执行系统命令和处理系统信号，这得益于 Rust 语言。

在接下来的部分中，我们将介绍管道之间进程的通信以及并发性。我们将证明为什么 Rust 可能是这方面的最佳选择。

原文链接：https://www.bexxmodd.com/post/systems-programming-with-rust-2

参考资料