25、深入探索：Rust 中的不安全代码与外部函数接口

深入探索：Rust 中的不安全代码与外部函数接口

1. 技术要求

在开始学习之前，需要确保相关工具已正确安装：
- 验证 rustup 、 rustc 和 cargo 是否正确安装，使用以下命令：

rustup --version
rustc --version
cargo --version

• 由于涉及 C 代码编译和二进制文件生成，需要在开发机器上设置 C 开发环境。设置完成后，运行以下命令验证安装是否成功：

gcc --version

如果该命令执行不成功，请重新检查安装。

注意 ：建议在 Windows 平台上开发的人员使用 Linux 虚拟机来尝试相关代码。代码已在 Ubuntu 20.04 (LTS) x64 上测试，应该适用于其他 Linux 变体。代码的 Git 仓库可在 此处 找到。

2. 引入不安全的 Rust

通常，Rust 语言在编译时强制执行内存和类型安全，防止各种未定义行为，如内存溢出、空指针或无效指针构造以及数据竞争，这就是安全的 Rust。Rust 标准库为编写安全、惯用的 Rust 代码提供了很好的工具和实用程序。

然而，在某些情况下，编译器可能会成为阻碍。Rust 编译器对代码进行保守的静态分析，可能会拒绝一些实际上安全的代码。例如系统调用、类型强制转换和直接操作内存指针等操作，在开发某些系统软件时会用到，但编译器可能认为这些操作有风险而拒绝。

在嵌入式系统中，通过固定内存地址访问寄存器需要解引用指针，为了实现这些操作，Rust 语言提供了 unsafe 关键字。这部分代码不遵循借用检查器的规则，被称为不安全的 Rust。可以将不安全的 Rust 视为安全 Rust 的超集，它允许执行标准 Rust 中的所有操作，还能执行一些被 Rust 编译器禁止的操作。

2.1 区分安全和不安全的 Rust 代码

Rust 提供了一种方便直观的机制，使用 unsafe 关键字将代码块括起来。例如以下代码：

fn main() {
    let num = 23;
    let borrowed_num = # // 对 num 的不可变引用
    let raw_ptr = borrowed_num as *const i32; // 将引用 borrowed_num 转换为原始指针
    assert!(*raw_ptr == 23);
}

使用 cargo check 编译此代码（或在 Rust 在线 IDE 中运行），会看到以下错误消息：

error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block

将解引用原始指针的操作放在 unsafe 块中修改代码：

fn main() {
    let num = 23;
    let borrowed_num = # // 对 num 的不可变引用
    let raw_ptr = borrowed_num as *const i32; // 将引用 borrowed_num 转换为原始指针
    unsafe {
        assert!(*raw_ptr == 23);
    }
}

此时编译成功，尽管这段代码可能会导致未定义行为。因为一旦将代码放在 unsafe 块中，编译器期望程序员确保不安全代码的安全性。

2.2 不安全 Rust 中的操作

不安全类别中主要有五种关键操作：
1. 解引用原始指针 ：不安全的 Rust 有两种新类型的原始指针， *const T 对应安全 Rust 中的 &T （不可变引用类型）， *mut T 对应 &mut T （可变引用类型）。与 Rust 引用类型不同，这些原始指针可以同时有不可变和可变指针指向同一个值，或者同时有多个指针指向内存中的同一个值。当这些指针超出作用域时，不会自动清理内存，并且这些指针可以为空或指向无效的内存位置。Rust 提供的内存安全保证不适用于这些指针类型。示例代码如下：

fn main() {
    let mut a_number = 5;
    // 创建一个指向值 5 的不可变指针
    let raw_ptr1 = &a_number as *const i32;
    // 创建一个指向值 5 的可变指针
    let raw_ptr2 = &mut a_number as *mut i32;
    unsafe {
        println!("raw_ptr1 is: {}", *raw_ptr1);
        println!("raw_ptr2 is: {}", *raw_ptr2);
    }
}

创建原始指针不需要 unsafe 块，但解引用时需要，因为解引用原始指针可能会导致不可预测的行为，借用检查器不负责验证其有效性或生命周期。
2. 访问或修改可变静态变量 ：静态变量有固定的内存地址，可以标记为可变。但如果静态变量标记为可变，访问和修改它是不安全的操作，必须放在 unsafe 块中。示例代码如下：

static mut THREAD_COUNT: u32 = 4;
use std::env::var;

fn change_thread_count(count: u32) {
    unsafe {
        THREAD_COUNT = count;
    }
}

fn main() {
    if let Some(thread_count) = var("THREAD_COUNT").ok() {
        change_thread_count(thread_count.parse::<u32>().unwrap());
    };
    unsafe {
        println!("Thread count is: {}", THREAD_COUNT);
    }
}

此代码声明了一个可变静态变量 THREAD_COUNT 并初始化为 4。 main 函数执行时，会查找名为 THREAD_COUNT 的环境变量，如果找到则调用 change_thread_count 函数在 unsafe 块中修改静态变量的值，最后在 unsafe 块中打印该值。
3. 实现不安全的 trait ：例如有一个包含原始指针的自定义结构体，要在跨线程间发送或共享该结构体，需要实现 Send 或 Sync trait。实现这些 trait 时需要使用不安全的 Rust，示例如下：

struct MyStruct(*mut u16);
unsafe impl Send for MyStruct {}
unsafe impl Sync for MyStruct {}

使用 unsafe 关键字的原因是原始指针的所有权未被跟踪，需要程序员负责跟踪和管理。

3. 引入外部函数接口（FFI）

FFI 可以解决一些实际问题，例如：
- 有一个用 Rust 编写的用于线性回归的快速机器学习算法，Java 或 Python 开发者想使用这个 Rust 库。
- 想在不使用 Rust 标准库的情况下进行 Linux 系统调用。

一种流行的解决方法是使用 FFI。在第一个例子中，可以用 Java 或 Python 定义的 FFI 包装 Rust 库；在第二个例子中，Rust 有 extern 关键字，可以设置并调用 C 函数的 FFI。

3.1 调用 C 函数的示例

use std::ffi::{CStr, CString};
use std::os::raw::c_char;

extern "C" {
    fn getenv(s: *const c_char) -> *mut c_char;
}

fn main() {
    let c1 = CString::new("MY_VAR").expect("Error");
    unsafe {
        println!("env got is {:?}", CStr::from_ptr(getenv(c1.as_ptr())));
    }
}

在 main 函数中，调用外部 C 函数 getenv 来检索 MY_VAR 环境变量的值。 getenv 函数接受 *const c_char 类型的参数，通过 CString 类型创建该参数，使用 as_ptr 方法转换为所需类型。 getenv 函数返回 *mut c_char 类型，使用 CStr::from_ptr 函数将其转换为 Rust 兼容的类型。

运行程序的命令如下：

MY_VAR="My custom value" cargo -v run --bin ffi

会在控制台看到 MY_VAR 的值。

3.2 注意事项

• extern "C" 块 ：指定对 C 函数的调用，包含要调用的函数的签名，函数中的数据类型是 C 语言的数据类型。
• 导入模块 ：从 Rust 标准库导入 std::ffi 和 std::os::raw 模块。 ffi 模块提供与 FFI 绑定相关的实用函数和数据结构，方便在非 Rust 接口之间进行数据映射； os::raw 模块包含特定于平台的类型，映射到 C 数据类型，确保与 C 交互的 Rust 代码引用正确的类型。

3.3 处理联合结构体

在 C 语言中使用的联合结构体不是内存安全的，因为可以将联合实例设置为一个变体，却以另一个变体的方式访问。Rust 在安全的 Rust 中不直接提供联合类型，但有标记联合，在安全的 Rust 中以枚举数据类型实现。示例代码如下：

#[repr(C)]
union MyUnion {
    f1: u32,
    f2: f32,
}

fn main() {
    let float_num = MyUnion {f2: 2.0};
    let f = unsafe { float_num.f2 };
    println!("f is {:.3}",f);
}

使用 #[repr(C)] 注解告诉编译器 MyUnion 联合中字段的顺序、大小和对齐方式与 C 语言中相同。创建联合实例并初始化为浮点值，在 unsafe 块中访问其值。运行程序：

cargo run

会看到 f is 2.000 。如果将访问代码改为 let f = unsafe { float_num.f1 }; 再次运行程序，会看到一个无效值，因为内存位置存储的浮点值被解释为整数。

4. 创建安全 FFI 接口的准则

在使用 FFI 与其他语言交互时，需要注意以下准则：
|准则|详情|
| ---- | ---- |
| extern 关键字|在 Rust 中使用 extern 关键字定义的任何外部函数本质上是不安全的，必须在 unsafe 块中调用。|
|数据布局| Rust 不保证数据在内存中的布局方式，但与其他语言交互时，显式使用与 C 兼容的布局（使用 #repr(C) 注解）对维护内存安全很重要。外部函数的参数和返回值应使用与 C 兼容的类型，如整数、浮点数、带有 repr(C) 注解的结构体和指针。Rust 中与 C 不兼容的类型包括 trait 对象、动态大小类型和带字段的枚举。可以使用 rust-bindgen 和 cbindgen 等工具生成 Rust 和 C 之间兼容的类型。|
|平台相关类型| C 有许多平台相关的类型，如 int 和 long ，其长度根据平台架构而异。与使用这些类型的 C 函数交互时，可以使用 Rust 标准库的 std::raw 模块提供的跨平台类型别名， libc crate 也提供了这些数据类型的可移植类型别名。|
|引用和指针|由于 C 的指针类型和 Rust 的引用类型不同，在跨 FFI 边界工作时，Rust 代码应使用指针类型而不是引用类型。任何解引用指针类型的 Rust 代码在使用前必须进行空检查。|
|内存管理|每种编程语言都有自己的内存管理方式，在语言边界之间传输数据时，必须明确哪个语言负责释放内存，以避免双重释放或使用后释放的问题。|

综上所述，通过了解不安全的 Rust 和 FFI，可以在必要时编写底层代码，与其他编程语言进行交互，但需要谨慎操作以确保代码的安全性。

5. 从 C 调用 Rust 函数（项目示例）

接下来我们探讨如何从 C 程序中调用 Rust 函数。首先需要创建一个 Rust 库，该库将导出一个可供 C 调用的函数。

5.1 创建 Rust 库

以下是一个简单的 Rust 库示例，它包含一个可以被 C 调用的函数：

#[no_mangle]
pub extern "C" fn add_numbers(a: i32, b: i32) -> i32 {
    a + b
}

• #[no_mangle] 注解：该注解告诉 Rust 编译器不要对函数名进行修饰，这样 C 代码可以直接使用该函数名。
• extern "C" ：指定函数使用 C 的调用约定，这使得 C 代码能够正确调用该函数。

将上述代码保存为 lib.rs ，并在项目根目录下创建 Cargo.toml 文件，内容如下：

[package]
name = "rust_lib"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["staticlib"]

这里 crate-type = ["staticlib"] 指定生成静态库，以便 C 代码可以链接使用。

然后在项目根目录下运行以下命令来构建静态库：

cargo build --release

构建完成后，会在 target/release 目录下生成 librust_lib.a 静态库文件。

5.2 创建 C 程序调用 Rust 函数

以下是一个简单的 C 程序，用于调用上述 Rust 库中的 add_numbers 函数：

#include <stdio.h>

// 声明 Rust 函数
extern int add_numbers(int a, int b);

int main() {
    int result = add_numbers(3, 5);
    printf("The result of adding 3 and 5 is: %d\n", result);
    return 0;
}

将上述 C 代码保存为 main.c 。

5.3 编译和链接 C 程序

在终端中使用以下命令编译和链接 C 程序：

gcc -o main main.c target/release/librust_lib.a

这里 -o main 指定生成的可执行文件名为 main ， main.c 是 C 源文件， target/release/librust_lib.a 是之前生成的 Rust 静态库文件。

运行生成的可执行文件：

./main

你将看到输出结果：

The result of adding 3 and 5 is: 8

6. 理解应用二进制接口（ABI）

应用二进制接口（ABI）定义了不同软件模块之间如何进行交互，包括函数调用约定、数据类型布局、寄存器使用等方面。在 Rust 中与其他语言进行交互时，理解 ABI 非常重要。

6.1 repr(C) 注解

在前面的示例中，我们已经使用了 #[repr(C)] 注解。该注解告诉 Rust 编译器使用 C 语言的数据布局规则，确保 Rust 结构体或联合的字段顺序、大小和对齐方式与 C 语言一致。例如：

#[repr(C)]
struct Point {
    x: i32,
    y: i32,
}

这样定义的 Point 结构体在 Rust 和 C 中具有相同的内存布局，方便在 FFI 中使用。

6.2 调用约定

在 Rust 中， extern "C" 表示使用 C 的调用约定。不同的调用约定在参数传递、栈清理等方面可能有所不同。例如，C 调用约定通常使用栈来传递参数，并且由调用者负责清理栈。在 Rust 中使用 extern "C" 可以确保 Rust 函数与 C 函数在调用时具有兼容性。

6.3 数据类型映射

在 FFI 中，需要确保 Rust 和其他语言的数据类型相互匹配。例如，Rust 的 i32 类型通常对应 C 语言的 int 类型， f64 类型对应 C 语言的 double 类型。Rust 标准库的 std::os::raw 模块提供了一些与 C 数据类型对应的类型别名，如 c_char 、 c_uint 等，方便在 FFI 中使用。

以下是一个简单的流程图，展示了在 Rust 中使用 FFI 与 C 交互的基本流程：

graph TD;
    A[Rust 代码] -->|生成静态库| B[librust_lib.a];
    C[C 代码] -->|包含 Rust 函数声明| D[main.c];
    B -->|链接| E[编译和链接];
    D -->|编译和链接| E;
    E -->|生成可执行文件| F[main];

7. 总结

通过本文的学习，我们深入了解了 Rust 中的不安全代码和外部函数接口（FFI）。不安全的 Rust 为我们提供了在必要时绕过编译器限制，编写底层代码的能力，主要包括解引用原始指针、访问或修改可变静态变量、实现不安全的 trait 等操作。而 FFI 则让 Rust 能够与其他编程语言进行交互，解决了不同语言之间的互操作性问题。

在使用不安全的 Rust 和 FFI 时，需要遵循一定的准则，如明确 extern 关键字的使用、注意数据布局、处理平台相关类型、正确使用引用和指针以及合理管理内存等，以确保代码的安全性和稳定性。

同时，我们还通过具体的示例展示了如何从 Rust 调用 C 函数以及从 C 调用 Rust 函数，并且介绍了应用二进制接口（ABI）的相关概念，这对于在不同平台上构建 Rust 二进制文件以及将 Rust 代码与其他语言代码进行链接非常有帮助。

希望本文能够帮助你更好地掌握 Rust 中不安全代码和 FFI 的使用，在实际开发中灵活运用这些技术，实现更强大的功能。