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

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

1. 技术基础准备

在开始探索 Rust 的不安全代码和外部函数接口（FFI）之前，需要确保相关开发环境正确安装。可以使用以下命令进行验证：

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

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

gcc --version

如果此命令执行不成功，请重新检查安装过程。对于在 Windows 平台上开发的用户，建议使用 Linux 虚拟机来尝试相关代码，代码已在 Ubuntu 20.04 (LTS) x64 上测试，应该也适用于其他 Linux 变体。

2. 引入不安全 Rust

2.1 安全 Rust 与不安全 Rust 的区别

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

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

为了支持这些操作，Rust 语言提供了 unsafe 关键字。不安全 Rust 可以被视为安全 Rust 的超集，它允许我们执行标准 Rust 中的所有操作，还能执行一些被编译器禁止的操作。Rust 自身的编译器和标准库中也包含了精心编写的不安全 Rust 代码。

2.2 区分安全和不安全 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 playground 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.3 不安全 Rust 中的操作

不安全类别中主要有五个关键操作：解引用原始指针、处理可变静态变量、实现不安全特性、通过 FFI 接口调用外部函数以及跨 FFI 边界共享联合结构体。下面先介绍前三个操作：
- 解引用原始指针 ：不安全 Rust 引入了两种新的原始指针类型， *const T 对应安全 Rust 中的 &T （不可变引用类型）， *mut T 对应 &mut T （可变引用类型）。与 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 块，但解引用它们时需要，因为解引用原始指针可能会导致不可预测的行为，借用检查器不会负责验证其有效性或生命周期。
- 访问或修改可变静态变量 ：静态变量有固定的内存地址，并且可以标记为可变。但如果静态变量被标记为可变，访问和修改它是不安全的操作，必须放在 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 块中修改静态变量的值。最后， main() 函数在 unsafe 块中打印出该值。
- 实现不安全特性 ：假设我们有一个包含原始指针的自定义结构体，想要在多个线程之间发送或共享它。根据并发管理的要求，一个类型要在多个线程之间发送或共享，需要实现 Send 或 Sync 特性。对于原始指针，实现这两个特性需要使用不安全 Rust，示例如下：

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

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

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

3.1 理解 FFI

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

一种常用的方法就是使用 FFI。在第一个例子中，可以用 Java 或 Python 定义的 FFI 来包装 Rust 库；在第二个例子中，Rust 提供了 extern 关键字，可以设置并调用 C 函数的 FFI。以下是一个调用 C 函数 getenv 来获取环境变量值的示例：

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 类型，为了将其转换为 Rust 兼容的类型，我们使用 Cstr::from_ptr() 函数。

这里有两个主要注意事项：
- 在 extern "C" 块中指定对 C 函数的调用，该块包含了我们要调用的函数的签名，注意函数中的数据类型是 C 语言的数据类型，而不是 Rust 数据类型。
- 从 Rust 标准库中导入 std::ffi 和 std::os::raw 模块。 ffi 模块提供了与 FFI 绑定相关的实用函数和数据结构，方便在非 Rust 接口之间进行数据映射； os::raw 模块包含了与 C 数据类型对应的平台特定类型，使与 C 交互的 Rust 代码能引用正确的类型。

可以使用以下命令运行程序：

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

运行后会在控制台打印出 MY_VAR 的值，这样我们就成功通过调用外部 C 函数获取了环境变量的值。

3.2 联合结构体与 FFI

在 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 语言中的期望一致。定义了联合的两个变体：一个是 u32 类型的整数，另一个是 f32 类型的浮点数。对于该联合的任何给定实例，只有一个变体是有效的。在代码中，创建了一个联合实例，用浮点数变体初始化它，然后在 unsafe 块中访问其值。

使用以下命令运行程序：

cargo run 

会在终端看到输出 f is 2.000 。如果尝试将联合作为整数而不是浮点数类型访问，只需修改一行代码：

let f = unsafe { float_num.f1 };

再次运行程序，不会得到错误，但会看到一个无效的值，这是因为内存位置中的值原本存储的是浮点数，现在被解释为整数。在 C 中使用联合是危险的，除非非常小心，而 Rust 提供了在不安全 Rust 部分使用联合的能力。

3.3 安全 FFI 接口的准则

在使用 Rust 的 FFI 与其他语言进行交互时，需要注意以下准则：
- extern 关键字 ：在 Rust 中使用 extern 关键字定义的任何外部函数本质上都是不安全的，此类调用必须在 unsafe 块中进行。
- 数据布局 ：Rust 不保证数据在内存中的布局方式，因为它负责内存的分配、重新分配和释放。但在与其他（外部）语言交互时，显式使用与 C 兼容的布局（使用 #repr(C) 注解）对于维护内存安全非常重要。另外，只有与 C 兼容的类型才能用作外部函数的参数或返回值。Rust 中与 C 兼容的类型包括整数、浮点数、带有 repr(C) 注解的结构体和指针；与 C 不兼容的 Rust 类型包括特征对象、动态大小类型和带有字段的枚举。有一些工具，如 rust-bindgen 和 cbindgen ，可以帮助生成 Rust 和 C 之间兼容的类型，但也有一些注意事项。

下面用表格总结与 C 兼容和不兼容的 Rust 类型：
| 兼容性 | Rust 类型示例 |
| ---- | ---- |
| 兼容 | 整数、浮点数、repr(C) 注解的结构体、指针 |
| 不兼容 | 特征对象、动态大小类型、带字段的枚举 |

以下是一个简单的 mermaid 流程图，展示调用 C 函数的基本流程：

graph TD;
    A[创建 CString 实例] --> B[转换为 *const c_char 类型];
    B --> C[调用 extern "C" 函数];
    C --> D[将返回值转换为 Rust 兼容类型];
    D --> E[在 unsafe 块中处理结果];

通过以上内容，我们对 Rust 中的不安全代码和 FFI 有了更深入的了解，掌握了相关的操作和注意事项，能够在合适的场景中使用它们来实现更复杂的功能。

4. 从 C 调用 Rust 函数（项目）

在前面我们已经了解了如何从 Rust 调用 C 函数，接下来我们将探讨如何从 C 调用 Rust 函数。

4.1 准备工作

首先，我们需要编写一个 Rust 函数，并且将其导出为可以被 C 调用的形式。以下是一个简单的 Rust 函数示例：

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

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

4.2 编译 Rust 代码为静态库

将上述 Rust 代码保存为 lib.rs ，然后使用以下命令将其编译为静态库：

cargo build --release --lib

编译完成后，在 target/release 目录下会生成一个静态库文件，例如 libyour_project.a 。

4.3 编写 C 代码调用 Rust 函数

接下来，我们编写一个 C 代码来调用这个 Rust 函数：

#include <stdio.h>

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

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

4.4 编译并运行 C 代码

使用以下命令编译 C 代码并链接 Rust 静态库：

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

运行生成的可执行文件：

./main

运行后，会在终端看到输出 The result is: 8 ，这表明我们成功地从 C 代码中调用了 Rust 函数。

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

5.1 ABI 的概念

应用二进制接口（ABI）定义了不同程序组件之间的二进制级别的交互规则，包括函数调用约定、数据类型的表示、内存布局等。在 Rust 中，理解 ABI 对于与其他语言进行交互非常重要，特别是在使用 FFI 时。

5.2 repr(C) 注解与 ABI

在前面的联合结构体示例中，我们使用了 #[repr(C)] 注解。这个注解告诉编译器结构体或联合的布局和对齐方式与 C 语言中的期望一致，确保在与 C 代码交互时不会出现内存布局不一致的问题。例如：

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

5.3 条件编译与 ABI

在不同的目标平台上，ABI 可能会有所不同。Rust 提供了条件编译的功能，可以根据不同的平台和配置来调整代码。例如：

#[cfg(target_os = "linux")]
fn platform_specific_function() {
    // Linux 平台特定的代码
}

#[cfg(target_os = "windows")]
fn platform_specific_function() {
    // Windows 平台特定的代码
}

5.4 数据布局约定

除了 repr(C) 注解，Rust 还提供了其他一些数据布局约定的注解，如 #[repr(packed)] 可以让结构体的字段紧密排列，减少内存空间的使用，但可能会影响性能。

5.5 给链接器提供指令

在编译和链接过程中，我们可以给链接器提供一些指令，例如指定链接的库文件、链接顺序等。在 C 代码中，我们可以使用 -l 和 -L 选项来指定链接的库和库的搜索路径。

以下是一个总结 ABI 相关内容的表格：
| 内容 | 说明 |
| ---- | ---- |
| repr(C) 注解 | 确保结构体或联合的布局和对齐方式与 C 语言一致 |
| 条件编译 | 根据不同的目标平台调整代码 |
| 数据布局约定 | 如 #[repr(packed)] 控制结构体字段的排列 |
| 链接器指令 | 指定链接的库和库的搜索路径 |

下面是一个 mermaid 流程图，展示从 C 调用 Rust 函数的整体流程：

graph TD;
    A[编写 Rust 函数并导出] --> B[编译 Rust 代码为静态库];
    B --> C[编写 C 代码声明并调用 Rust 函数];
    C --> D[编译 C 代码并链接 Rust 静态库];
    D --> E[运行生成的可执行文件];

总结

通过以上内容的学习，我们全面了解了 Rust 中的不安全代码和外部函数接口（FFI）相关知识：
1. 不安全 Rust ：掌握了不安全 Rust 的概念、与安全 Rust 的区别，以及不安全 Rust 中的关键操作，如解引用原始指针、处理可变静态变量、实现不安全特性等。
2. FFI ：理解了 FFI 的作用，学会了从 Rust 调用 C 函数，以及从 C 调用 Rust 函数的方法。
3. ABI 相关知识 ：了解了应用二进制接口（ABI）的概念，以及如何使用 repr(C) 注解、条件编译、数据布局约定和给链接器提供指令来确保不同语言代码之间的正确交互。

在实际开发中，我们可以根据具体需求，合理使用不安全 Rust 和 FFI 来实现更复杂的功能，与其他语言进行有效的交互。但同时也要注意遵循相关的准则和注意事项，确保代码的安全性和稳定性。