Rust - 第 13 章：系统编程和嵌入式开发 - 《程序员的必备修养》

文件和目录操作
- 文件读写
- 目录操作
进程和信号处理
- 创建子进程
- 信号处理
网络编程
- TCP 服务器
- HTTP 服务器
嵌入式系统开发

keywords: 系统编程, 嵌入式开发, Rust 文件操作, 网络编程, 信号处理

在本章中，我们将探讨 Rust 语言在系统编程和嵌入式开发中的应用。Rust 的内存安全性和高性能特性使其成为系统级编程和嵌入式开发的理想选择。我们将涵盖以下内容：

文件和目录操作
进程和信号处理
网络编程
嵌入式系统开发

文件和目录操作

文件和目录操作是系统编程的基础。Rust 提供了丰富的标准库来处理这些任务。

文件读写

使用 std::fs 模块可以轻松实现文件的读写操作。以下是一个简单的示例：

use std::fs::File;
use std::io::{self, Read, Write};
fn main() -> io::Result<()> {
    // 创建文件
    let mut file = File::create("hello.txt")?;
    file.write_all(b"Hello, Rust!")?;
    // 读取文件
    let mut file = File::open("hello.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    println!("File contents: {}", contents);
    Ok(())
}

目录操作

使用 std::fs 模块还可以实现目录的创建、读取和删除等操作：

use std::fs;
fn main() -> std::io::Result<()> {
    // 创建目录
    fs::create_dir("example_dir")?;
    // 读取目录
    for entry in fs::read_dir("example_dir")? {
        let entry = entry?;
        println!("Found file: {}", entry.path().display());
    }
    // 删除目录
    fs::remove_dir("example_dir")?;
    Ok(())
}

进程和信号处理

进程和信号处理是系统编程的核心部分。Rust 提供了 std::process 模块来处理子进程的创建和管理，还可以使用 nix crate 进行更高级的信号处理。

创建子进程

使用 std::process::Command 可以创建和管理子进程：

use std::process::Command;
fn main() {
    let output = Command::new("echo")
        .arg("Hello, world!")
        .output()
        .expect("Failed to execute command");
    println!("Output: {}", String::from_utf8_lossy(&output.stdout));
}

信号处理

使用 nix crate 可以处理 Unix 信号：

use nix::sys::signal;
use nix::unistd::Pid;
fn main() {
    // 给当前进程发送 SIGINT 信号
    signal::kill(Pid::this(), signal::Signal::SIGINT).unwrap();
}

graph LR
A[主进程] -- 创建 --> B[子进程1]
A -- 创建 --> C[子进程2]
B -- 发送信号 --> A
C -- 发送信号 --> A

网络编程

Rust 提供了强大的网络编程支持，可以处理 TCP 和 UDP 连接以及 HTTP 请求。tokio 和 hyper 是常用的异步网络编程库。

TCP 服务器

以下是一个简单的 TCP 服务器示例：

use std::net::{TcpListener, TcpStream};
use std::io::{Read, Write};
use std::thread;
fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 512];
    stream.read(&mut buffer).unwrap();
    stream.write(&buffer).unwrap();
}
fn main() {
    let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
    println!("Server listening on port 7878");
    for stream in listener.incoming() {
        let stream = stream.unwrap();
        thread::spawn(|| {
            handle_client(stream);
        });
    }
}

HTTP 服务器

使用 hyper 创建一个简单的 HTTP 服务器：

use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
async fn handle(req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("Hello, World!")))
}
#[tokio::main]
async fn main() {
    let make_svc = make_service_fn(|_conn| {
        service_fn(|req| handle(req))
    });
    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(make_svc);
    println!("Listening on http://{}", addr);
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}

嵌入式系统开发

Rust 也适用于嵌入式系统开发。通过使用 cortex-m 和 cortex-m-rt 等 crate，可以在 ARM Cortex-M 微控制器上编写嵌入式应用。

设置开发环境

首先，安装 cargo-generate 和 thumbv7em-none-eabihf 工具链：

cargo install cargo-generate
rustup target add thumbv7em-none-eabihf

创建嵌入式项目

使用 cortex-m-quickstart 模板创建一个新的项目：

cargo generate --git https://github.com/rust-embedded/cortex-m-quickstart

编写嵌入式程序

以下是一个简单的 LED 闪烁示例：

#![no_std]
#![no_main]
use cortex_m_rt::entry;
use panic_halt as _;
use stm32f4xx_hal::{pac, prelude::*};
#[entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    let gpioc = dp.GPIOC.split();
    let mut led = gpioc.pc13.into_push_pull_output();
    loop {
        led.set_high().unwrap();
        cortex_m::asm::delay(8_000_000);
        led.set_low().unwrap();
        cortex_m::asm::delay(8_000_000);
    }
}

通过本章的学习，我们掌握了 Rust 在系统编程和嵌入式开发中的应用。通过文件和目录操作、进程和信号处理、网络编程以及嵌入式系统开发的实例，我们更深刻地理解了 Rust 的强大和灵活性。

在实际应用中，合理选择和使用这些技术，可以帮助我们开发出高效、安全和可靠的系统级和嵌入式应用程序。